3 강.

printf 로 출력하기

printf(" 서식문자 포함 ",인자 1 ,인자 2, 인자 3, ......);

1. %d : 정수 출력

2. %f : 실수 출력 / 자동으로 소수점 6 자리까지 출력

cf) %.2f : 소수점 둘째자리까지만 반올림해서 출력

3. %g : 실수 출력 / 지수 형태로도 출력

4. %c : 문자 출력 / 알파벳, 숫자, 몇몇 기호, \n / 한글, 한자, 유니코드 X

5. %s : 문자열 출력

*** \n : 줄바꿈

4 강. 변수

변수 이름 규칙 : 알파벳 대소문자 구별 , _ , 숫자(첫번째 글자 불가능)

변수 선언 : int a;

변수 선언과 동시에 초기화 : int a = 3;

변수에 값을 대입 : a = 3;

5 강. 자료형

변수의 자료형 : 정수형 / 실수형

1. 정수형
- char (1 바이트) : 문자
- short (2 바이트)
- long (4 바이트)
- long long (8 바이트)
- int (4 바이트) : %d

2. 실수형
- float (4 바이트) : %f
- double (8 바이트)

*** signed / unsigned int

*** void : 리턴값이 없는 함수의 자료형

*** bool : 참/거짓을 저장

*** 변수의 연산 : + , - , * , /(몫) , %(나머지)

*** 2 진법 : 맨처음 비트 부호비트 + 숫자 크기

*** 2 의 보수법 : 비트를 모두 반전( 0 -> 1 , 1 -> 0 ) 시킨 다음 1 을

더해준다

6 강. Sizeof 연산자 + 형변환

sizeof(x) : x 의 크기를 알려줌 (바이트 단위 기준)

x : 변수의 자료형 (int , float , ...) or 변수의 이름

*** 정수형 변수에 실수를 담을 수 없다

*** 실수형 변수에 정수를 담을 수 있다

형변환 : 자료형을 다른 자료형으로 바꾸는 작업

int sum = a + b + c;
double avg = (double)sum / 3;

*** 정수 / 정수 = 정수
*** 실수 / 정수 = 실수
*** 실수 / 실수 = 실수

*** 정수 + 정수 = 정수
*** 정수 + 실수 = 실수
*** 실수 + 실수 = 실수

7 강. Scanf 로 입력받기

int a, b;
scanf("%d%d", &a, &b); // & : 포인터

스페이스바 / 엔터키를 누르면 자동으로 입력으로 간주해서 변수에 대입해준다

*** %d : 정수 입력 (int)

*** %f : 실수 입력 (float)

*** %c : 문자 입력

*** scanf 가 실행이 안되면 scanf_s 사용

8 강. Char 형 + ASCII 코드

char : 1 바이트 정수형 , 문자 저장용 자료형

char a = 67;

printf("%d", a); = 67

printf("%c", a); = C

printf("%c", 'C'); = C

printf("%d", 'C'); = 67

*** 'C' 는 67 이라는 값을 가진다 ( 'C' = 67 )

*** ASCII 코드 : 문자 – 숫자의 대응 관계를 알려주는 표

10 강. 산술연산자

산술연산자 : 수학적인 연산

*** + , - , * , / , % , =

*** += , -= , *= , /= , %=

*** ++ , --

1. = : 대입 연산 ( 오른쪽 값을 왼쪽 값에 저장한다 )

2. a += 6; 은 a = a + 6; 과 같은 문장

3. ++ / -- : 증가 / 감소 연산자

a++; 은 a = a + 1; 과 같고 a += 1; 과 같다 ( a 값이 1 증가 )

*** 전치와 후치

++a : 전치 증가 연산 b = ++a : 먼저 a 값을 1 증가시킨 다음에 a

값을 b 에 대입한다
a++ : 후치 증가 연산 b = a++ : 먼저 a 값을 b 에 대입한 다음에 a
값을 1 증가시킨다

11 강. 비교연산자 + 논리연산자

bool (1 바이트) : 진리값을 저장하는 변수 자료형

참 : 1
거짓 : 0

*** 비교연산자

1. == : 같다

2. != : 다르다

3. >= , <=

*** 논리연산자

1. && : 그리고 and

2. || : 또는 or

3. ! : 부정(~가 아니다) , 참을 거짓으로 , 거짓을 참으로

12 강. If 문

제어문 : if / while / for

if 문으로 경우 나누기

1. if - else 문 : 2 가지 경우 나누기

if (조건) {
조건을 만족하면 실행;
}
else {
조건을 만족하지 않으면( 거짓 : 0 ) 실행;
}

*** 0 이 아닌 숫자는 참으로 인식하므로 if (300) { 무조건 실행됨; }

2. if - else if - else 문 : 3 가지 이상의 경우 나누기

if (조건 1) {
조건 1 을 만족하면 실행;
}
else if (조건 2) {
조건 2 를 만족하면 실행;
}
else {
그외 나머지 경우에 실행;
}

13 강. 중첩 if 문
중첩 if 문
중괄호 코딩 스타일

*** if 문 { } 안에 ; 가 한 개 있으면 { } 생략 가능

*** a , b , c 중에서 최대값 출력하는 프로그램 코딩

int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);

if (a > b) {
if (a > c) {
printf("%d\n", a);
}
else {
printf("%d\n", c);
}
}
else {
if (b > c) {
printf("%d\n", b);
}
else {
printf("%d\n", c);
}
}
}

14 강. Switch 문

switch (변수) {
case 1: ---> 변수 = 1 인 경우
~~~;
break;

case 2:
~~~;
break;

ㅣ
ㅣ
ㅣ

default : ----> 그외 나머지 경우 (else)

~~~~;
break;

*** break : { } 밖으로 나간다

break 가 없으면 case2 3 4 순서대로 실행된다

15 강. While 문

반복문

1. while 문

while ( 조건 ) {
반복;
}
조건을 만족할 경우에만 { } 안의 반복문을 실행한다
조건을 만족하지 않는 경우에는 { } 를 빠져나오거나 아예 들어가지를 않는다

2. do - while 문

do {
반복문
} while ( 조건 )

조건 만족여부와 관계없이 처음에 한 번은 { } 를 실행한다

그 이후 조건을 만족하면 { } 를 반복한다

3. 무한 반복

while (true) {
반복문
}

16~17 강. For 문

1. for 문

int i;
for (i = 1; i <= 10; i++) {
~~~;
}

*** for (초기값; 조건; 조건 만족시 { } 수행후 i 값 1 증가한 다음 조건을

다시 확인)

*** 조건 만족하지 않게 되면 바로 { } 를 빠져나온다

*** 일정하게 증가/감소되는 변수가 필요할 때 for 문 사용

*** 배열의 모든 원소에 순차적으로 접근하고 싶을 때 for 문 사용

*** 특정 횟수만큼 작업을 반복하고 싶을 때 for 문 사용

*** { } 안에서만 선언된 변수는 { } 안에서만 사용된다 : for(int i = 1; ~~;

~~) { }

*** 조건 생략하면 항상 true 로 간주한다

2. while 문으로 바꾼다면

int i;
i = 1;
while (i <= 10) {
~~~;
i++;
}

18 강. 중첩 for 문

1. break : 반복문 한 개를 빠져 나옴

for (int i = 1; ;i++) {

int k;
scanf("%d", &k);

if (k = 0) {
break;
}

printf("%d 번째 : %d\n", i, k);

2. continue : 반복루프명령을 한 번 건너뜀

3. 중첩 for 문

int n;
scanf("%d", &n);

for (int i = 1; i <= n; i++) {

for(int j = 1; j <= n; j++) {

printf("*");
}

printf("\n");
}

20 강. 1 차원 배열

int a[5];
// 크기가 5 인 1 차원 배열 선언 : a = { a[0], a[1], a[2], a[3], a[4] }

a[0] = 2; // 배열의 첫요소는 0 부터 시작한다

a[1] = 3;
a[2] = 7;

for (int i = 0; i <= 4; i++) {

a[i] = i * 5;
}

for (int i; i <= 4; i++) {

printf("%d\n", a[i]);
}

*** int arr[5] = { 3, 1, 4, 1, 5 };

*** int arr[] = { 3, 1, 4, 1, 5 };

// { } 이용하여 배열 선언시 배열의 크기 생략가능하다
*** sizeof(arr) / sizeof(int) = 배열의 크기 (원소 개수)

21 강. 배열의 활용 예제

1. 배열에 숫자를 입력받아 거꾸로 출력하기

int n;
int arr[1000];
printf("입력할 숫자의 개수 입력 : ");
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
for(int i = n-1; i >= 0; i--) {
printf("%d ", arr[i]);
}

2. 최대 / 최소 구하기

int n;
int arr[1000];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
int max = arr[0];
for (int i = 1; i < n; i++) {
if ( max < arr[i]) {
max = arr[i];
}
}
printf("%d\n", max);

3. 짝수 / 홀수의 개수 구하기

int n;
int arr[1000];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
int cnt = 0;
for (int i = 1; i < n; i++) {
if ( arr[i] % 2 == 0 ) {
cnt++;
}
}
printf("%d\n", cnt);
22 강. 2 차원 배열

int arr[3][4]; // 크기 3 행 4 열 인 배열 선언

int arr[3][4] = {
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12}
};

*** 2 차원 배열 : 중첩 for 문 사용하므로 변수 i (행번호) 와 j (열번호) 선언

---> 열이 행보다 빠르게 움직인다

for (int i = 0; i < 3; i++) {

for(int j = 0; j < 4; j++) {

printf("%d ", arr[i][j]);
}

printf("\n")

*** 파스칼의 삼각형 : [i][j] = [i-1][j-1] + [i-1][j] +

( j == 0 || j == i) ---> 1

23 강. 문자열 : 문자(char 형 변수)들이 열거된 배열

*** char arr[] = { 'a' , 'b' , 'c' , ~ } = "abc~";
printf("%s\n", arr);

*** 배열의 크기 = sizeof(arr) / sizeof(char) = 문자의 개수 + 1

(문자열 맨 끝에 널문자 자동 포함)

*** 문자열의 길이 = sizeof(arr) / sizeof(char) - 1

*** char arr[] = "abc" = { 'a', 'b', 'c', '\0' };

*** 널문자 ( \0 ) : 문자열의 끝을 알려준다

*** 변수부터 선언해준 다음에 입력 받거나 출력한다

*** 문자열을 입력받을 때에는 &표시 안한다

char s[];
scanf("%s", s);

*** 문자열과 관련된 함수를 사용하려면 #include <string.h> 부터 선언

*** 문자열의 길이 출력 함수 : strlen(문자열)

char str[100] = "Hello";
int len;
len = strlen(str);

*** 문자열 복사해주는 함수 : strcpy(사본, 원본)

char str1[] = "Hello";
char str2[100];
strcpy(str2, str1);

*** 문자열에 다른 문자열을 덧붙여주는 함수 : strcat(문자열, 덧붙일 문자열)

char str[100] = "Hello";
strcat(str, "World!");

*** 두 문자열을 비교(1 이 2 보다 사전순으로 앞/뒤/같은지(-1/1/0) 해주는

함수 : strcmp(문자열 1, 문자열 2)

24 강. 포인터 : 가리킬 변수의 주소값을 저장하는 변수

*** 포인터는 변수를 가리킨다

int a = 20;

int *ptr_a;
// 포인터 변수 ptr_a 선언 ( 가리킬 변수의 자료형 *포인터변수이름 )

ptr_a = &a;
// &a : 변수 a 의 주소값을 반환
// &a( 변수 a 의 주소값 ) 을 포인터 변수에 저장
// 메모리상 int 형 변수 a 가 차지하는 4 칸 (4 바이트) 중 첫번째 칸의 주소값이
저장된다

*** *ptr_a = a ( *ptr_a : 포인터변수 ptr_a 가 가리키는 변수 a 를 사용 )

printf("a 의 값 : %d\n", a);

printf("a 의 주소값 : %d\n", &a (ptr_a) );
printf("ptr_a 에 저장된 값 : %d\n", ptr_a);
printf("ptr_a 가 가리키는 변수의 값 : %d\n", *ptr_a);

int a = 10;

int *ptr; // a 를 가리키는 포인터변수 ptr 선언

ptr = &a;

int **ptr_ptr;
// a 를 가리키는 포인터변수 ptr 을 가리키는 포인터변수 ptr_ptr 선언
ptr_ptr = &ptr;

*** **ptr_ptr = *(*ptr_ptr) = *ptr = a

25 강. 배열과 포인터의 관계

int a;
int *ptr_a = &a; // 포인터변수 ptr_a 선언과 동시에 초기화

ptr_a + 1 = 변수 a 의 주소값 + 변수 a 의 자료형의 크기 ( 4 )

// 메모리 상에서 변수 a 의 바로 옆칸에 있는 변수의 주소값 = a 의 주소값 + 4

int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8 ,9 ,10 };

*** arr = &arr[0] // arr 의 값 = arr[0] 의 주소값
---> 배열 arr[10] 선언시 배열 arr 의 첫번째 칸 arr[0] 을 가리키는
포인터변수 arr 이 자동으로 생성된다
---> 따라서 arr 은 배열의 한 칸( 첫번째 칸 )만을 가리킨다
---> 배열 전체를 가리키고 싶다면 배열 포인터( &arr) 사용

*** arr + i = &arr[0] + 4 * i = &arr[i] ---> sizeof(arr[0]) = 4

int *ptr = arr;

// 포인터 변수 ptr 에 포인터변수 arr 의 값( arr[0]의 주소값 = &arr[0] )
저장

26 강. 배열 포인터

int *ptr = arr;

*(ptr + i) = *(arr + i)

arr[i] = ptr[i]

arr[i] = *(arr + i) = *(ptr + i) = *(i + ptr) = i[ptr]

---> 원리 : a[b] = *(a + b) ---> 실무에선 쓰지마라

*** arr or ptr or &arr 대입시 성립하는 공식

1. arr = &arr[0]
---> 배열의 한 칸 (첫번째 칸) 만을 가리키는 포인터 변수
---> 배열포인터가 아니다!!!
2. *arr = arr[0]

3. arr + 1 = arr + sizeof(*arr)

ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

배열 포인터 : 배열 자체만을 가리키는 포인터

*** 배열 arr 전체의 주소 = &arr = arr[0] 의 주소 = &arr[0]

int arr[3] = { 1, 2, 3 };

int(*ptr_arr)[3];
// 길이 3 인 int 형 배열 arr 을 가리키는 배열 포인터 변수 ptr_arr 을 선언
---> 오직 배열만 가리킬수있다

ptr_arr = &arr;

*(ptr_arr)[i] = arr[i]

27 강. 2 차원 배열과 배열 포인터

int arr[2][3]; // 2 행 3 열의 배열 선언

sizeof(arr) = 4 * 6 = 24 ( 2 차원 배열 전체의 크기 )
sizeof(arr[0]) = 4 * 3 = 12 ( 2 차원 배열에서 첫번째 배열 ( 1 행 ) 의 크기
)
sizeof(arr[0][0]) = 4 ( 1 행 1 열 의 크기 )

*** &arr = &arr[0] = &arr[0][0]

1. arr = &arr[0]
2. *arr = arr[0]
3. arr + 1 = &arr[0] + sizeof(*arr)

int arr[2][3];
int(*ptr)[3] = arr ( = &arr[0] );
// 크기가 3 인 1 차원 배열을 가리키는 배열 포인터 변수 ptr 선언

1. ptr[i] = *(ptr + i) = arr[i]

// ptr 은 1 행 전체를 가리키는 포인터이고 ptr 에 1 을 더할 때마다 그 다음
행을 가리킨다

2. ptr[i][j] = arr[i][j] ---> arr 대신 ptr 사용가능 ( ptr = arr )

// 배열 ( 1 차원 or 2 차원 ) 을 포인터로 치환하고 싶으면
배열의 첫번째 행 ( arr or arr[0] )을 가리킬수 있는 포인터변수를 만들어서
첫번째 행의 주소값 ( &arr or &arr[0] ) 을 저장하면 된다

*** 포인터 : int *ptr = arr; // 배열 arr 의 첫번째 칸을 가리키는 포인터

변수
*** 배열포인터 : int(*ptr)[크기] = arr;
// 배열 arr 의 첫번째 배열을 가리키는 포인터 변수

int arr[2][3] = { {1, 2, 3} , {4, 5, 6} };

for (int(*row)[3] = arr; row < arr + 2; row++) {
for(int *col = *row; col < *row + 3; col++) {
---> *row 자체가 하나의 배열을 의미하므로 col = *row = &(*row)[0] 이 된다
printf("%d ", *col);
}
printf("\n");
}
28 강. 포인터 배열

배열 포인터 : 배열을 가리키는 포인터 ---> 포인터가 한 개

포인터 배열 : 포인터들이 배열 ---> 포인터가 여러개

int(*ptr)[4]; // 크기가 4 인 배열을 가리키는 배열 포인터

int *ptr[4]; // 크기가 4 인 포인터 배열 ---> 주소값들의 배열

ptr[0] = &a; // *ptr[0] = a
ptr[1] = &b;
ptr[2] = &c;
ptr[3] = &d;

*** 문자열의 출력 원리
문자열 = char 형 배열
char str[] = "Hello";
printf("%s\n", str ( = &str[0] ) );
--> printf + %s : 배열의 첫번째칸의 포인터를 입력해주면 널문자가
나올때까지 자동으로 출력해준다
char strings[3][10] = { "Hello", "World", "Doodle" };
for( int i = 0; i < 3; i++) {
printf("%s\n", strings[i] ( = &strings[i][0] ) )
---> &strings[i] 는 배열 자체를 가리키므로 오류 발생
}

char strings[3][10] = { "Hello", "World", "Doodle" };

char *p_str[3];
for( int i = 0; i < 3; i++) {
p_str[i] = strings[i] ( = &strings[i][0] )
}

31 강. 함수

*** main 함수
Int main() {
Printf( ) // 이미 선언된 함수 printf 를 호출한다 (stdio.h 에 포함)
}

*** 함수
반환형 함수명(자료형 매개변수 1, 자료형 매개변수 2, ~ ) {
~~~
}

*** 함수의 { } 밖에서 전역변수를 먼저 선언해주면 { } 안에서도 사용가능

지역변수와 매개변수는 { } 안에서만 사용가능

*** 반환형 : int / void (반환값 x) / double

32 강. 함수의 반환

Return : 반환

*** 2 개의 매개변수(정수)의 합을 반환하는 함수

Int plus(int a, int b) {
return a + b
}

*** 한 함수 내에 return 이 여러 개 있어도 첫번째 return 까지만 유효하다

Return 을 한 번이라도 만나면 즉시 함수가 종료된다

*** 반환형이 int 인 함수의 종료 : return 정수;

반환형이 void 인 함수의 종료 : return;