$$config title: C언어 2 keywords: - 방학반 - 8월 $$ # 수업자료 - [비주얼 스튜디오 다운로드](https://visualstudio.microsoft.com/ko/downloads/) - [C 라이브러리](https://cplusplus.com/reference/clibrary/) - [코딩 그라운드](https://www.tutorialspoint.com/codingground.htm) - [만족도 조사](http://st.koreaedugroup.com/2019/login.asp) - [C언어 1](https://slog.gg/p/12638)
# 기본세팅 세팅 오른쪽 마우스에서 속성 Alt + Enter 속성 페이지 -> C/C++ -> 일반 -> SDL검사 -> 아니요(/sdl-) 속성 페이지 -> C/C++ -> 전처리기 전처리 -> 정의에 추가 \_DEBUG;\_CONSOLE;%(PreprocessorDefinitions); \_CRT_SECURE_NO_WARNINGS 끝에 ;(세미콜론) 꼭넣어주기 또는 ```c #define _CRT_SECURE_NO_WARNINGS #pragma warning(disable:4996) ```

# 8월 9일 - 1일차 #### 응용문제 2 > 길이가 8인 배열 arr을 선언하고 1,2,3,4,5,6,7,8로 초기화 합니다. 이배열의 마지막 요소를 가리키는 포인터 변수 ptr을 선언 ptr에 저장된 값을 감소시키는 방식으로 배열의 모든 요소에 점근하여 배열 요소 중 홀수에 해당하는 값들의 총합을 구해 출력 ```c int main(void) { int arr[8] = { 1,2,3,4,5,6,7,8 }; int* ptr = &arr[7]; int sum = 0; for (int i = 0; i < 8; i++) { if (*(ptr - i) % 2 == 1) { sum += *(ptr - i); } } printf("배열 요소중 홀수의 총합은 : %d", sum); return 0; } // 출력 // 배열 요소중 홀수의 총합은 : 16 ``` 사이즈가 변할 수 있을 경우 ```c int main(void) { int arr[] = { 1,2,3,4,5,6,7,8 }; int size = sizeof(arr) / sizeof(int); int* ptr = &arr[size-1]; int sum = 0; for (int i = 0; i < size; i++) { if (*(ptr - i) % 2 == 1) { sum += *(ptr - i); } } printf("배열 요소중 홀수의 총합은 : %d", sum); return 0; } ```
#### 응용문제 3 > 길이가 8인 배열 arr을 선언하고 1,2,3,4,5,6,7,8로 초기화 합니다. 첫번째 요소를 가리키는 포인터와, 마지막을 가리키는 포인터 선언 두 포인터 활용 arr요소가 역순으로 나열되도록 변경 ```c int main(void) { int arr[] = { 1,2,3,4,5,6,7,8,9 }; int* sp = arr; int size = sizeof(arr) / sizeof(int); int* ep = &arr[size-1]; for (int i = 0; i < size; i++) { printf("%d ", arr[i]); } printf("\n"); for (int i = 0; i < size/2; i++) { int temp = *(ep-i); arr[size-(i+1)] = *(sp+i); arr[i] = temp; } for (int i = 0; i < size; i++) { printf("%d ", arr[i]); } return 0; } // 출력 // 1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1 ```

## 다차원 배열 > 2차원 이상의 배열을의미 배열의 요소가 선형적으로 나열되어 있는 형태 > 2차원 int arrs\[5]\[3] : 세로 5, 가로 3인 2차원 배열 3차원 int arrt\[2]\[3]\[4] : 높이 2, 세로 3, 가로 4인 3차원 배열 >배열선언 int a\[]\[] = {{1},{2}}; 불가 int a\[2]\[1] = {{1},{2}}; 가능 ```c int main(void) { int arrs[2][2] = { {1,2}, {3,4} }; printf("%d\n", arrs[0][0]); printf("주소 [0][0] = %p\n", &arrs[0][0]); printf("주소 [1][0] = %p\n", &arrs[1][0]); //8차이 int arrt[2][2][2]; printf("주소 [0][0][0] = %p\n", &arrt[0][0][0]); printf("주소 [1][0][0] = %p\n", &arrt[1][0][0]); //16차이 int arr1[3] = {1}; printf("%d\n", arr1[1]); int arr2[2][3] = { {1,2},{3,4} }; printf("%d\n", arr2[0][2]); return 0; } // 출력 // 1 주소 [0][0] = 000000775639F988 주소 [1][0] = 000000775639F990 주소 [0][0][0] = 000000775639F9B8 주소 [1][0][0] = 000000775639F9C8 0 0 ```
다차원 배열 보기 좋게 선언 ```c int main(void) { int a[2][3] = { {1,2,3}, {4,5,6} }; int b[2][3][4] = { { {1,2,3,4}, {5,6,7,8}, {9,10,11,12} }, { {13,14,15,16}, {17,18,19,20}, {21,22,23,24} } }; return 0; } ```

#### 2차원 배열의 저장과 출력 2차원 배열의 사이즈 확인 ```c int main(void) { int a; int arr[2][3]; printf("%d\n",sizeof(arr)/4); //2*3 = 6 printf("%d\n",sizeof(arr[0]) / 4); // 3 printf("%d\n", sizeof(arr) / sizeof(arr[0])); // 24/12 = 2 return 0; } // 출력 // 6 3 2 ```
2차원 배열 1~배열 사이즈 만큼 저장 후 출력 ```c int main(void) { int c = 1; int arr[2][3]; int si = sizeof(arr) / sizeof(arr[0]); int sj = sizeof(arr[0]) / 4; for (int i = 0; i < si; i++) { for (int j = 0; j < sj; j++) { arr[i][j] = c; c++; } } for (int i = 0; i < si; i++) { for (int j = 0; j < sj; j++) { printf("%d ", arr[i][j]); } printf("\n"); } return 0; } // 출력 // 1 2 3 4 5 6 ```
사이즈 확대 ```c int arr[5][10]; // 출력 // 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 ```

#### 3차원 배열의 저장과 출력 3차원 배열 사이즈 확인 ```c int main(void) { int a[2][3][4]; printf("%d\n", sizeof(a) / 4); //2*3*4 = 24 printf("%d\n", sizeof(a) / sizeof(a[0])); // 96/48 = 2 printf("%d\n", sizeof(a[0]) / sizeof(a[0][0])); // 48/16 =3 printf("%d\n", sizeof(a[0][0]) / 4); // 16/4 = 4 return 0; } // 출력 // 24 2 3 4 ```
3차원 배열 저장 및 출력 ```c int main(void) { int a[2][3][4]; int si = sizeof(a) / sizeof(a[0]); int sj = sizeof(a[0]) / sizeof(a[0][0]); int sk = sizeof(a[0][0]) / 4; int c = 1; for (int i = 0; i < si; i++) { for (int j = 0; j < sj; j++) { for (int k = 0; k < sk; k++) { a[i][j][k] = c; c++; } } } for (int i = 0; i < si; i++) { for (int j = 0; j < sj; j++) { for (int k = 0; k < sk; k++) { printf("%d ", a[i][j][k]); } printf("\n"); } printf("\n"); } return 0; } // 출력 // 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ```
사이즈 확대 ```c int a[5][5][5]; // 출력 // 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 ```

# 8월 10일 - 2일차 ### 배열 포인터 > 포인터 변수를 요소로 가지는 배열을 의미함 int a\[2]\[5]; 에서 주소값 확인 ```c int main(void) { int a[2][5]; printf("%p\n", &a); printf("%p\n", &a[0]); printf("%p\n", &a[1]); return 0; } // 출력 // 00000097A715F778 00000097A715F778 00000097A715F78C ``` 16진수계산 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f 16증가하면 10의 자리에 1증가 4증가 8에서 4증가 c 즉 16진수 78에서 20이 증가하면 8C ```c int main(void) { printf("\n"); printf("%x\n", 8+20); return 0; } // 출력 // 1c ``` a배열을 포인터에 넣어서 출력 하면 ```c int* p = &a; printf("%p\n", p); printf("%p\n", p+1); // 출력 // 000000C4E936F6B8 000000C4E936F6BC //4증가 ```
주소값에 있는거 확인하고 싶으면 ```c int main(void) { int a[2][5]; int* p = &a; printf("%p\n", p); printf("%p\n", p+1); printf("========\n"); a[0][0] = 1; a[0][1] = 100; printf("%d\n", *p); printf("%d\n", *(p + 1)); return 0; } // 출력 // 000000DE5C51F578 000000DE5C51F57C ======== 1 100 ```

##### 배열포인터 >int(\*p)\[5] = a; ```c int main(void) { int a[2][5]; int(* p)[5] = a; printf("%p\n", p); printf("%p\n", a[0]); printf("========\n"); printf("%p\n", p+1); printf("%p\n", a[1]); return 0; } // 출력 // 00000058B20FF608 00000058B20FF608 ======== 00000058B20FF61C 00000058B20FF61C ```
주소값 확인 ```c int main(void) { int a[2][5]; int(*p)[5] = a; printf("%p\n", p); printf("%p\n", p[0]); printf("%p\n", &p[0][0]); return 0; } // 출력 // 000000F6012FF568 000000F6012FF568 000000F6012FF568 == 1 10 ``` 주소값확인 ```c int main(void) { int a[2][5]; int(*p)[5] = a; printf("%p\n", p); printf("%p\n", p[0]); printf("%p\n", &p[0][0]); printf("==\n\n"); printf("%p\n", &a[1]); printf("%p\n", p+1); printf("%p\n", p[1]); printf("%p\n", &p[1][0]); return 0; } // 출력 // 00000012CB6FF7A8 00000012CB6FF7A8 00000012CB6FF7A8 == 00000012CB6FF7BC 00000012CB6FF7BC 00000012CB6FF7BC 00000012CB6FF7BC ```
포인터배열 과 배열 포인터 ```c int main(void) { int a[2][5]; int(*p)[5] = a; int* p2[5] = { &a[0][0],&a[0][1],&a[0][2],&a[0][3],&a[0][4] }; printf("%p\n", p[0]); printf("%p\n", p2[0]); printf("%p\n", &p[0][1]); printf("%p\n", p2[1]); return 0; } // 출력 // 000000CEC9D4F618 000000CEC9D4F618 000000CEC9D4F61C 000000CEC9D4F61C ```

>int (\*p) \[5] = a; p= 5개짜리 배열을 저장하고 있는 배열 포인터 ```c int main(void) { int a[2][5]; int(*p)[5] = a; a[0][0] = 1; a[1][0] = 100; printf("%d\n", *p[0]); printf("%d\n", *p[1]); a[0][1] = 2; printf("===\n\n"); printf("%d\n", p[0][0]); printf("%d\n", p[0][1]); return 0; } // 출력 // 1 100 === 1 2 ```
배열 포인터 차원증가 ```c int main(void) { int a[2][5][2]; int(*p)[5][2] = a; a[0][0][0] = 1; a[1][0][0] = 100; printf("%d\n", *p[0][0]); printf("%d\n", *p[1][0]); a[0][0][1] = 2; printf("===\n\n"); printf("%d\n", p[0][0][0]); printf("%d\n", p[0][0][1]); return 0; } // 출력 // 1 100 === 1 2 ``` 주소값 ```c int main(void) { int a[2][5][2]; int(*p)[5][2] = a; printf("%p\n", p[0][0]); printf("%p\n\n", &a[0][0]); printf("%p\n", p[1][0]); printf("%p\n", &a[1][0]); return 0; } // 출력 // 000000729DBBF860 000000729DBBF860 000000729DBBF888 000000729DBBF888 ```
주소값 심화 ```c int main(void) { int a[2][5][2]; int(*p)[5][2] = a; printf("%p\n", p[0][0]); printf("%p\n", p[0]); printf("%p\n\n", &a[0][0][0]); printf("%p\n", p + 1); printf("%p\n", p[1]); printf("%p\n\n", &a[1][0][0]); printf("%p\n", p[0] + 1); printf("%p\n", p[0][1]); printf("%p\n", &a[0][1][0]); return 0; } // 출력 // 000000618FB6F5B0 000000618FB6F5B0 000000618FB6F5B0 000000618FB6F5D8 000000618FB6F5D8 000000618FB6F5D8 000000618FB6F5B8 000000618FB6F5B8 000000618FB6F5B8 ```

# 8월 11일 - 3일차 ### 응용문제 #### 응용문제 1 >행 3, 열 3인 char형 2차원 배열 bingo를 선언하고 다음과 같이 값이 저장되도록 프로그램을 작성해 보세요. 단 선언과 동시에 초기화하지 않고 선언 이후에 따로 초기화를 진행하세요. O X X X O X X X O for문의 중첩을 사용해 보세요. ```c int main(void) { char b[3][3]; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (i == j) { b[i][j] = 'O'; } else { b[i][j] = 'X'; } } } for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { printf("%c ", b[i][j]); } printf("\n"); } return 0; } // 출력 // O X X X O X X X O ``` 발전 X X X O O O X X X ```c if (i == 1) { b[i][j] = 'O'; } ``` #### 응용문제 2 >행 4, 열 9인 2차원 배열을 선언하고, 배열의 각 요소에 구구잔 2단부터 5단까지의 결과를 저장하세요. 하나의 행이 하나의 단을 의미합니다. 저장을 마친 후 모든 요소를 다음과 같이 출력하는 프로그램을 작성해 보세요. 2 4 6 8 10 12 14 16 18 3 6 9 12 15 18 21 24 27 4 8 12 16 20 24 28 32 36 5 10 15 20 25 30 35 40 45 ```c int main(void) { int a[4][9]; for (int i = 0; i < 4; i++) { for (int j = 0; j < 9; j++) { a[i][j] = (i + 2) * (j + 1); printf("%d ", a[i][j]); } printf("\n"); } return 0; } ```
#### 응용문제 3 결과 예상 ```c #include int main(void) { int arr[3][2] = { {6, 7}, {8, 9}, {3, 4} }; printf("%d %d\n", arr[1][0], arr[0][1]); // 8 7 printf("%d %d\n", *(arr[2] + 1), *(arr[1] + 1)); //4 9 printf("%d %d\n", (*(arr + 2))[0], (*(arr + 0))[1]); // 3 7 printf("%d %d\n", **arr, *(*(arr + 0) + 0)); // 6 6 return 0; } // 출력 // 8 7 4 9 3 7 6 6 ```

# 8월 14일 - 4일차 #### 종합문제 1 > 길이가 5인 int 1차원 배열 만들고 최대값, 최소값, 총합계 ```c int main(void) { int a[5]; int s = 0, max, min; for (int i = 0; i < 5; i++) { printf("NUM%d : ", i + 1); scanf("%d", &a[i]); s += a[i]; if (i == 0) { max = a[i]; min = a[i]; } if (min > a[i]) { min = a[i]; } if (max < a[i]) { max = a[i]; } } printf("\n\n최대값 : %d\n최소값 : %d\n총합계 : %d", max, min, s); return 0; } // 출력 // NUM1 : 5 NUM2 : 8 NUM3 : 6 NUM4 : 11 NUM5 : 2 최대값 : 11 최소값 : 2 총합계 : 32 ```
#### 종합문제 2 > 길이가 8인 인트 선언 정수 8개 입력 홀수 : 짝수 : 나오게 하기 ```c int main(void) { int a[8]; for (int i = 0; i < 8; i++) { printf("NUM%d : ", i + 1); scanf("%d", &a[i]); } printf("\n\n홀수 : "); for (int i = 0; i < 8; i++) { if (a[i] % 2 != 0) { printf("%d ", a[i]); } } printf("\n짝수 : "); for (int i = 0; i < 8; i++) { if (a[i] % 2 == 0) { printf("%d ", a[i]); } } return 0; } // 출력 // NUM1 : 2 NUM2 : 12 NUM3 : 5 NUM4 : 8 NUM5 : 3 NUM6 : 45 NUM7 : 18 NUM8 : 71 홀수 : 5 3 45 71 짝수 : 2 12 8 18 ```
# 8월 16일 - 5일차

#### 종합문제 3 > 입력받은 숫자를 분리하여 모두출력 4자리 입력 첫번째 제외한 나머지 숫자 출력 첫번째와 두번째 제외한 나머지 출력 숫자 한개가 출력될 때까지 반복 출력 숫자형 ```c int main(void) { int a; printf("숫자 입력 >> "); scanf("%d", &a); int c = 10000; for (int i = 0; i < 4; i++) { printf("%d \n", a % c); c /= 10; } return 0; } ``` 자리수 상관 없이 ```c int main(void) { int a; printf("숫자 입력 >> "); scanf("%d", &a); int b = a; int s = 0; while (1) { s++; b /= 10; if (b == 0) { break; } } printf("s = %d\n", s); int c = 1; for (int i = 0; i < s; i++) { c *= 10; } for (int i = 0; i < s; i++) { printf("%d \n", a % c); c /= 10; } return 0; } ``` 문자형으로 출력 ```c int main(void) { char a[5]; printf("숫자 : "); scanf("%s", a); for (int i = 0; i < 4; i++) { for (int j = 0; j < 4 - i; j++) { printf("%c ", a[j+i]); } printf("\n"); } return 0; } // 출력 // 숫자 : 6789 6 7 8 9 7 8 9 8 9 9 ``` 몇개의 숫자가 되는지 상관없이 ```c int main(void) { int a; printf("숫자 : "); scanf("%d", &a); int b = a; int c = 1; while(1) { b /= 10; if (b == 0) { break; } c++; } int c2 = c; int arr[10]; for (int i = a; i > 0; i = i / 10) { arr[c2 - 1] = i % 10; c2--; } c2 = c; for (int i = 0; i < c; i++) { for (int j = 0; j < c2; j++) { printf("%d ", arr[c2-(j+1)]); } printf("\n"); c2 = c - (i+1); } return 0; } // 출력 // 숫자 : 2156847 7 4 8 6 5 1 2 4 8 6 5 1 2 8 6 5 1 2 6 5 1 2 5 1 2 1 2 2 ```
자리수 상관없이 ```c int main(void) { int a; printf("숫자 입력 >> "); scanf("%d", &a); int b = a; int s = 0; while (1) { s++; b /= 10; if (b == 0) { break; } } int arr[11]; int c = 1; for (int i = 0; i < s-1; i++) { c *= 10; } for (int i = 0; i < s; i++) { arr[i] = a / c; a %= c; c /= 10; } for (int i = 0; i < s; i++) { for (int j = 0 ; j < s-i; j++) { printf("%d ", arr[i+j]); } printf("\n"); } return 0; } ```
주소 확인하여 몇개든 상관없이 %S로 출력하기 ```c int main() { char a[20]; printf("입력 >> "); scanf("%s", a); int c = 0; for (;a[c]!='\0';c++) { } for (int i = 0; i < c; i++) { printf("%s", &a[i]); printf("\n"); } return 0; } ```
#### 종합문제 4 > 문자열 변수를 선언하고 문자열을 저장 해당문자열을 앞에서부터 읽었을 때와 뒤에서 부터 읽었을 때 동일한 문자인지 검사하는 프로그램 작성 > 예시 문자열 입력 : level 동일합니다. 문자열 입력 : hellow 동일하지 않습니다. ```c int main(void) { int main() { char a[20]; printf("입력 >> "); scanf("%s", a); int c = 0; for (;a[c]!='\0';c++) { } int e = c; int n = 0; for (int i = 0; i < c; i++) { --e; if (a[i] == a[e]) { n++; } } if (c == n) { printf("동일"); } else { printf("비동일"); } return 0; } // 출력 // 문자열 입력 : asdfgfdsa 동일합니다. 문자열 입력 : asddsa 동일합니다. 문자열 입력 : asdasd 동일하지 않습니다. ```

# 8월 17일 - 6일차 #### 종합문제 5 > 연수와 월수를 입력받아 달력을 출력하는 프로그램을 작성해 보세요 조건은 다음과 같습니다. '기본 코드를 제공하지만 반드시 기본코드를 따르지는 않아도 됩니다. 조건 4로 나누어지는 해는 윤달(2월 29일)이 있다. 100으로 나누어지는 해는 윤달이 없다. 400으로 나누어지는 해는 윤달이 있다. 출력 연수 출력 월수를 각각 따로 입력 받는다. 요일 확인 2023년 1월 1일 일요일 2024년 1월 1일 월요일 2025년 1월 1일 수요일 2029년 1월 1일 월요일 ```c int main(void) { int year = 2029; int check = (year / 4) - (year / 100) + (year / 400); printf("%d년 %d", year, ((year * 365) + check) % 7); // 0이면 일요일 return 0; } // 출력 // 2023년 0 2024년 2 // 오류 24년 윤년이지만 2월 전까지는 더할 필요 없는데 더해줌 2025년 3 2029년 1 ```
윤년 해결 ```c int main(void) { int year = 2023; int check = (year / 4) - (year / 100) + (year / 400); if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) { check -= 1; } printf("%d년 %d", year, ((year * 365) + check) % 7); // 0이면 일요일 return 0; } // 출력 // 2023년 0 2024년 1 2025년 3 ```
2월 윤년 추가 ```c int main(void) { int days[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 }; int year = 2024; int month = 10; int check = (year / 4) - (year / 100) + (year / 400); if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) { check -= 1; days[1] += 1; } printf("%d년 %d\n", year, ((year * 365) + check) % 7); // 0이면 일요일 printf("2월 %d일", days[1]); return 0; } // 출력 // 2024년 1 2월 29일 2025년 3 2월 28일 1900년 1 2월 28일 ```
월 확인 ```c int main(void) { int days[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 }; int year = 2023; int month = 1; int check = (year / 4) - (year / 100) + (year / 400); if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) { check -= 1; days[1] += 1; } for (int i = 0; i < month-1; i++) { // 10월 이전까지의 날 수 check += days[i]; } int week = ((year * 365) + check) % 7; printf("%d년 %d월 1일 %d\n", year,month, week); // 0이면 일요일 return 0; } // 출력 // 2023년 1월 1일 0 2023년 2월 1일 3 2023년 3월 1일 3 ```
달력 출력 ```c int main(void) { int days[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 }; int year = 2023; int month = 1; int check = (year / 4) - (year / 100) + (year / 400); if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) { check -= 1; days[1] += 1; } for (int i = 0; i < month-1; i++) { // 10월 이전까지의 날 수 check += days[i]; } int week = ((year * 365) + check) % 7; printf("%d년 %d월 달력\n", year, month); printf("SUM\tMON\tTUS\tWED\tTHU\tFRI\tSAT\n"); printf("=====================================================\n"); for (int i = 0; i < week; i++) { //일요일 이면 0번, 월요일 1번 텝 printf("\t"); } for (int i = 0; i < days[month-1]; i++) { // 월 인덱스 printf("%3d\t", i+1); // 1부터 if ((week + i + 1) % 7 == 0) { //시작요일 + i + 1이 7로 나누어떨어지는 printf("\n"); } } return 0; } // 출력 // 2023년 1월 달력 SUM MON TUS WED THU FRI SAT ===================================================== 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ```

### 입력 및 종료 최종본 ```c int main(void) { int days[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 }; int year; int month; printf("출력 연도 : "); scanf("%d", &year); printf("출력 월 : "); scanf("%d", &month); int check = (year / 4) - (year / 100) + (year / 400); if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) { check -= 1; days[1] += 1; } for (int i = 0; i < month-1; i++) { // 10월 이전까지의 날 수 check += days[i]; } int week = ((year * 365) + check) % 7; printf("\n%d년 %d월 달력\n", year, month); printf("SUM\tMON\tTUS\tWED\tTHU\tFRI\tSAT\n"); printf("=====================================================\n"); for (int i = 0; i < week; i++) { //일요일 이면 0번, 월요일 1번 텝 printf("\t"); } for (int i = 0; i < days[month-1]; i++) { // 월 인덱스 printf("%3d\t", i+1); // 1부터 if ((week + i + 1) % 7 == 0) { //시작요일 + i + 1이 7로 나누어떨어지는 printf("\n"); } } return 0; } // 출력 // 출력 연도 : 2023 출력 월 : 2 2023년 2월 달력 SUM MON TUS WED THU FRI SAT ===================================================== 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 ```

## 문자열과 함수 ### 문자와 문자열 기본적인 문자열표현 ```c int main(void) { char a[] = "hellow"; printf("%c\n", a[1]); printf("%s\n", a); return 0; } // 출력 // e hellow ```
문자열 표현의 변화 > 문자열은 배열을 기반으로 정의할 수 있는 데이터 배열의 이름은 첫번째 요소의 주소를 의미 다음과 같이 진행 가능 ```c int main(void) { char *a = "good"; printf("%c\n", a[1]); printf("%s\n", a); return 0; } // 출력 // o good ```
포인터 기반의 문자열 제한 > 포인터 기반 문자열은 개별 요솟값 할당 불가능 > 배열 기반의 문자열 변수 변수형태의 문자열 이라고 함 > 포인터 기반의 문자열 변수 상수 형태의 문자열 이라고 함 ```c int main(void) { char *a = "good"; char b[] = "nice"; // a[0] = 'h'; // 에러 b[0] = 'g'; a = "hello"; printf("%s, %s\n", a, b); printf("%c, %c", a[0], b[0]); return 0; } // 출력 // hello, gice h, g ```

# 8월 18일 - 7일차 #### 문자열 관련 함수 > putchar(출력문자); // 문자정보 출력 getchar(); // 입력데이터 반환 ```c int main(void) { int ch1, ch2; ch1 = getchar(); ch2 = getchar(); putchar(ch1); printf("\n"); putchar(ch2); return 0; } // 출력 // asda a s ``` 변형 ```c int main(void) { double ch1, ch2; ch1 = getchar(); ch2 = getchar(); putchar(ch1); printf("\n"); putchar(ch2); return 0; } // 출력 // asdf a s ``` 출력확인 ```c int main(void) { double ch1, ch2; ch1 = getchar(); ch2 = getchar(); printf("%d\n", ch1); putchar(ch1); printf("\n"); putchar(ch2); return 0; } // 출력 // asdf 0 a s ``` 인트형태 출력 ```c int main(void) { int ch1, ch2; ch1 = getchar(); ch2 = getchar(); printf("%d\n", ch1); putchar(ch1); printf("\n"); putchar(ch2); return 0; } // 출력 // 12 49 1 2 ```
for문형태로 변경 ```c int main(void) { int ch; for (int i = 0; i < 10; i++) { ch = getchar(); putchar(ch); } return 0; } // 출력 // hellomynameiskim hellomynam 안녕하세요제이름은 안녕하세요 ```
무한 반복문 형태로 변경 >EOF End Of File 표준상수로 문자를 입력할때 입력이 종료되었음을 의미 키보드로 문자를 입력하고 Ctrl + Z 로 반환 ```c int main(void) { int ch; for (;;) { ch = getchar(); if (ch == EOF) { break; } putchar(ch); } return 0; } // 출력 // asd asd as as ^Z ```

#### 문자열 단위 입출력 함수 > puts(출력할 문자열); gets(pointer) >gets함수는 키보드로 입력되는 문자열을 인자로 전달된 주소에 저장함 문자열 끝에 자동으로 널 문자 삽입 ```c int main(void) { char ch[30]; //개수 넘으면 에러 gets(ch); puts(ch); printf("%s",ch); return 0; } // 출력 // asdasd asdasd asdasd ``` int로 해도 상관없음 ```c int main(void) { int ch[30]; gets(ch); puts(ch); printf("%s",ch); return 0; } // 출력 // asdaasd asdaasd asdaasd ```

#### 문자열 처리함수 > 문자열 처리함수 쓰기전 #include ##### strlen(str) > 문자열 길이출력 ```c #include #include int main(void) { int* a1 = "apple is good"; char a2[50] = "good"; printf("%d, %d\n", strlen(a1), strlen(a2)); printf("%s, %s",a1,a2); return 0; } // 출력 // 13, 4 apple is good, good ```
##### strcpy() , strncpy() > strcpy() 2번째 문자열을 1번째에 복사 char a\[] 배열로 넣어야 함 >strncpy() 2번째 문자열을 1번째에 3번째 숫자만큼 복사 마지막 \0값을 넣어줘야 확인 가능 ```c int main(void) { char a1[50] = "apple is good"; char a2[50] = "abcde"; char b1[50], b2[50]; strcpy(b1, a1); strcpy(b2, a1); strncpy(b2, a2, 4); printf("%s\n%s",b1,b2); return 0; } // 출력 // apple is good abcde is good ```
##### strcat(), strncat() > 문자열을 붙임, n은 몇개 ```c int main(void) { char a1[50] = "apple"; strcat(a1, " hello"); printf("%s\n",a1); strncat(a1, " abcdef",3); printf("%s\n",a1); return 0; } // 출력 // apple hello apple hello ab ```
##### strcmp(), strncmp() > 문자열 비교, n은 몇개 다를경우 -a 컴파일러마다 다름 같을경우 0 반환 ```c int main(void) { char a1[50] = "apple"; char a2[50] = "apple abc"; printf("cmp : %d\n", strcmp(a1, a2)); printf("ncmp : %d\n", strncmp(a1, a2,5)); return 0; } // 출력 // cmp : -1 ncmp : 0 ```

#### 응용문제 ##### 응용문제 1 >사용자로부터 두 개의 이름(문자열)을 입력받아 두 이름이 같은지 또는 같지 않은지를 알려주는 프로그램을 작성해 보세요. ```c int main(void) { char a1[20]; char a2[20]; gets(a1); gets(a2); if (strcmp(a1, a2) == 0) { puts("같습니다."); } else { puts("같지 않습니다."); } return 0; } // 출력 // 리오넬 메시 리오넬 메시 같습니다. ```
##### 응용문제 2 > 두개의 문자열을 입력받아 길이가 긴 문자열부터 순서대로 출력하는 프로그램을 작성해 보세요. ```c int main(void) { char a1[20]; char a2[20]; gets(a1); gets(a2); if (strlen(a1) >= strlen(a2)) { puts(a1), puts(a2); } else { puts(a2), puts(a1); } return 0; } // 출력 // hello i love you i love you hello ```
##### 응용문제 3 > 적당한 길이의 문자열을 입력받아 그 안에 존재하는 숫자(1-9)까지의 총합을 출력하는 프로그램을 작성해 보세요. 입력된 문자열에는 문자, 숫자, 기호등이 섞여있을 수 있으며 실행 예와 같이 숫자의 합만 구하여 출력합니다. >'0' = 48 '1' = 49 '9' = 57 57 - 48 = 9 49 - 48 = 1 ```c int main(void) { char a[20]; puts("문자열 입력"); gets(a); int s = 0; for (int i = 0; i < strlen(a);i++) { if (a[i] >= 48 && a[i] <= 57) { s += a[i]-48; //'0' } } printf("숫자의 합 : %d",s); return 0; } // 출력 // 문자열 입력 asd123kas 숫자의 합 : 6 ```

# 8월 21일 - 8일차 ## 메모리구조 > 프로그램을 실행하면 운영체제는 프로그램을실행 시킬 수 있도록 메모리 공간을 마련 메모리 공간은 변수나 코드 등들 저장하는데 사용됨 메모리 공간은 구분되어 효율을 높임
>RAM (Random Access Memory) 사용자가 자유롭게 내용을 읽고 쓰고 지울 수 있는 기억장치 컴퓨터가 부팅되는 순간부터 CPU는 연산을 하고 동작에 필요한 모든 내용이 전원이 유지되는 내내 저장된다. 전원이 차단되면 내용이 지워지며 휘발성 기억장치라고 한다.
> 유형과 목적에 따라 메모리 공간의 영역이 나누어짐 Code Segment 코드(Code) 영역 : 컴퓨터가 이해하는 형태로 컴파일 된 코드 Data Segment 데이터(Data) 영역 : 전역변수, Static 변수, 문자열 / (컴파일시 생성) 번역되는 과정에서 힙(Heap) 영역 : 동적할당 영역 (원하는 시점에 메모리공간을 할당하고 원하는 시점에 소멸) 자유영역 Stack Segment 스택(Stack) 영역 : 지역변수, 함수 Parameter(매개변수) / 런타임시 생성
>전역변수와 지역변수는 생성되는 시점 및 저장되는 영역이 다름 전역변수 Global Variable, 지역변수 Local Variable ```c #include int a; // Data 영역 생성 int main(void) { int b = 2; //Stack영역 생성 printf("%d, %d\n", a, b); //Stack영역 생성 a = 2; a--; b++; printf("%d, %d", a, b); //Stack영역 생성 b++; return 0; } // 출력 // 0, 2 1, 3 ```
> Stack Segment Stack의 데이터 성질 LIFO (Last In First Out) 마지막에 들어온 데이터가 먼저 나간다.

#### 응용문제 ##### 응용문제 1 > 데이터 유형이 어떤 영역에 저장되는지 지역변수, 매개변수 - Stack 전역변수 - Data 프로그램 코드 - Code
##### 응용문제 2 > Stack 영역은 어떤 데이터들이 저장되고 특성은? Stack 영역에는 지역변수, 매개변수들이 저장 마지막에 들어온 데이터가 먼저 나간다.
##### 응용문제 3 > 컴파일하고 실행시 프로그램 시작부터 종료할 때까지 스택영역의 변화 ```c int main(void) { int n = 20; char a = 'a'; printf("%c\n", a); printf("%d\n", n); return 0; } ``` 스택영역에 n 변수 생성 및 초기화 a변수 생성 및 초기화 printf 함수 실행 종료 printf 함수 실행 종료 a변수 종료 n변수 종료

## 함수 > main 함수는 C언어 프로그램의 시작과 끝임 함수 몸체에 정의된 실행문이 곧 프로그램의 기능(동작)을 의미함.
함수의 구성요소 반환형 : 함수로부터 반환할 데이터의 자료형태 함수의 이름 : 함수를 호출시 사용할 이름값 입력데이터 표현(매개변수) : 함수에 전달할 인자의 형태를 정의 함수의 기능 : 함수가 호출되었을때 실행할 기능을 정의
사용자 정의 함수 사용자가 기본적으로 실행하는 방식과 순서를 정하여 제작되는 함수로 함수를 구성하여 사용
기본적으로 선언및 정의를 main함수보다 위에 만드는 것이 기본이지만 컴파일러의 종류에 따라 밑에 작성해도 문제는 없음 위에 만들어주는 것이 기본임
기본구성 ```c #include int main(void) { int n = add(5, 10); printf("%d\n", n); return 0; } int add(int a, int b) { return a + b; } // 출력 // 15 ```
새로운 변수를 생성하여 인수로 지정할 수 있음. ```c int main(void) { int a = 10, b = 5; int n = add(a, b); printf("%d + %d = %d\n", a,b,n); return 0; } int add(int a, int b) { return a + b; } ```
입력값을 주어서 시행 ```c int main(void) { int a , b; scanf("%d %d", &a, &b); int n = add(a, b); printf("%d + %d = %d\n", a,b,n); return 0; } int add(int a, int b) { return a + b; } ```

### 함수의 형태 > 매개변수의 유무, 반환값의 유무에 따라 4가지 종류 -입력값 유, 반환값 유 -입력값 유, 반환값 무 -입력값 무, 반환값 유 -입력값 무, 반환값 무
> 입력값 유, 반환값 유 매개변수를 2개 입력받아 큰수를 반환하는 함수 ```c int big(int a, int b) { int c = a; if (a <= b) { c = b; } return c; } int main(void) { int r = big(3, 8); printf("큰값은 : %d", r); return 0; } // 출력 // 큰값은 : 8 ```
> 입력값 유, 반환값 무 반환값이 없을경우 void로 선언 ```c void big(int a, int b) { int c = a; if (a <= b) { c = b; } printf("큰값은 : %d", c); } int main(void) { big(3, 8); return 0; } // 출력 // 큰값은 : 8 ```
> 입력값 무, 반환값 유 ```c int big() { int a, b; printf("두수 입력 "); scanf("%d %d", &a,&b); int c = a; if (a <= b) { c = b; } return c; } int main(void) { int c = big(); printf("큰값은 : %d", c); return 0; } // 출력 // 두수 입력 2 9 큰값은 : 9 ```
> 입력값 무, 반환값 무 반환값이 없을경우 void로 선언 ```c void big() { int a, b; printf("두수 입력 "); scanf("%d %d", &a, &b); int c = a; if (a <= b) { c = b; } printf("큰값은 : %d", c); } int main(void) { big(); return 0; } // 출력 // 두수 입력 5 11 큰값은 : 11 ```

### 변수의 생명주기 > 지역변수 특정지역에서만 사용할 수 있는변수 지역이란 블록(중괄호)에서만 사용됨

지역변수의 특징 중괄호 내에 선언된 모든 변수 함수의 매개변수도 지역변수의 일종 자신이 선언한 지역 외 다른 영역 사용불가 선언 지역이 다를 경우 중복되어도 문제되지 않음 ```c void add(int a, int b) { // 매개변수 에러 int a = 10, b =2; printf("a = %d, b = %d", a, b); } int main(void) { add(1, 5); //변수 미선언 에러 printf("a = %d, b = %d", a, b); return 0; } ```
변형 ```c void add(int a, int b) { int a2 = 10, b2 =2; printf("a = %d, b = %d", a+a2, b+b2); } int main(void) { add(1, 5); return 0; } // 출력 // a = 11, b = 7 ```

> 전역변수 모든 지역에서 접근가능한 변수

전역변수 특성 프로그램 시작과 동시에 메모리 공간에 할당 모든 영역에서 접근 가능 전역변수와 동일 지역변수 선언시 지역내에서는 전역대신 지역이 사용됨 초기화를 변수로서 불가, 초기화 하지 않으면 0으로 자동 초기화
전역변수를 아래쪽에 선언할 수 없음 매개변수와 전역변수가 같은경우 함수내에서는 매개변수를 사용
변수로서 초기화 ```c int a = 1; //심볼릭 상수 int b = a; //에러 상수로만 가능 ``` define 상수는 가능 ```c #define a 10; int b = a; ``` 초기화 하지 않으면 0 ```c int a; int main() { printf("%d", a); return 0; } // 출력 // 0 ```
기본 사용 ```c int a = 10; void add(int a) { printf("%d", a); } int main(void) { add(5); return 0; } // 출력 // 5 ```
동일한 이름의 변수선언되었을때 부터는 메인함수에서 지역변수를 참조하여 출력 ```c int a = 10; void add(int a) { printf("%d\n", a); } int main() { add(a); int a = 1; add(a); return 0; } // 출력 // 10 1 ```
함수내에서 값을 변경해서 사용가능 예시1 ```c int a = 10; void add(int a) { printf("%d\n", a); } int main() { add(a); a = 5; //전역변수의 변경 add(a); return 0; } // 출력 // 10 5 ```
예시2 add함수에 출력을 전역변수로 지정함 ```c int a = 10; void add(int b) { printf("%d\n", a); } int main() { add(2); a = 5; add(a); return 0; } // 출력 // 10 5 ```
예시3 함수를 실행하면서 전역변수의 값을 변동 ```c int a = 10; void add(int b) { a = 100; printf("%d\n", a); } int main() { add(2); a = 5; // 순서변경시 값이 5임 add(a); printf("%d", a); return 0; } // 출력 // 100 100 100 ```
> 지역변수의 소멸 확인 ```c void a() { int a = 1; a++; printf("%d\n", a); } int main() { a(); a(); return 0; } // 출력 // 2 2 ```
전역변수 일 경우 ```c int a1 = 1; void a() { // 스스로 자신의 함수이름과 영향을 받아서 변경 a1++; printf("%d\n", a1); } int main() { a(); a(); return 0; } // 출력 // 2 3 ```

> static 변수 (정적변수) 지역내에서 선언하지만 소멸되지 않음 ```c void pf() { static int a = 1; printf("%d\n", a); a++; } int main() { pf(); pf(); pf(); return 0; } // 출력 // 1 2 3 ```

# 8월 22일 - 9일차 #### 응용문제 ##### 응용문제 1 > 두개의 정수를 매개변수로 받아 두정수의 덧셈, 뺄셈, 곱셈, 나눗셈 모두 출력 main에서 이를 호출 ```c void pf(int a, int b) { printf("%d + %d = %d\n", a, b, a + b); printf("%d - %d = %d\n", a, b, a - b); printf("%d * %d = %d\n", a, b, a * b); printf("%d / %d = %d\n", a, b, a / b); } int main() { pf(7,3); return 0; } // 출력 // 7 + 3 = 10 7 - 3 = 4 7 * 3 = 21 7 / 3 = 2 ```
##### 응용문제 2 > 두개의 매개변수로 입력받아 두정수 사이에 있는 모든 정수의 합을 구하여 반환하는 함수를 정의 main에서 호출 > 출력 : 5 와 9 사이의 정수의 총합은 21 ```c void pf(int a, int b) { int c = 0; for (int i = a+1; i < b; i++) { c += i; } printf("%d 와 %d 사이의 정수의 총합은 %d", a, b, c); } int main() { pf(5,9); return 0; } // 출력 // 5 와 9 사이의 정수의 총합은 21 ```
##### 응용문제 3 > 한개의 정수를 매개 변수로 입력받아 입력받은수와 그 수보다 200 더 큰 정수사이에 7의 배수가 몇개나 존재하는지를 구하고 그 결과를 반환하는 함수 구현 예) 100 전달시 300사이의 7의 배수가 몇개인지 확인 ```c void pf() { int a; printf("정수를 입력하세요 : "); scanf("%d", &a); int c = 0; for (int i = a; i < a + 200; i++) { if (i % 7 == 0) { c++; } } printf("%d 와 %d 사이의 7의 배수는 %d개 입니다.", a, a+200, c); } int main() { pf(); return 0; } // 출력 // 정수를 입력하세요 : 6 6 와 206 사이의 7의 배수는 29개 입니다. 정수를 입력하세요 : 100 100 와 300 사이의 7의 배수는 28개 입니다. ``` 변형 ```c void pf() { int a; printf("정수를 입력하세요 : "); scanf("%d", &a); printf("%d 와 %d 사이의 7의 배수는 %d개 입니다.", a, a+200, (a+200)/7-a/7); } int main() { pf(); return 0; } ```
##### 응용문제 4 > 사용자로부터 키를 cm로 입력받아 m단위로 환산하여 출력하는 프로그램 작성 함수를 정의하고 키를 인자로 받아 cm를 m단위로 반환 ```c float f(int a) { float b = a / 100.0; return b; } int main() { int a; printf("키입력 cm단위 : "); scanf("%d", &a); float b = f(a); printf("결과 : %.2fm", b); return 0; } // 출력 // 키입력 cm단위 : 181 결과 : 1.81m ```
##### 응용문제 5 > 사용자로부터 초를 입력받아 사용자 함수에 인자로 전달 매개변수로 초 입력(정수) 시/분/초 형태 출력 ```c void f(int a) { printf("%d시간/%d분/%d초",a/3600,a%3600/60,a%60); } int main() { int a; printf("몇 초 : "); scanf("%d", &a); f(a); return 0; } // 출력 // 몇 초 : 3615 1시간/0분/15초 ```

## 함수심화 ### 배열을 전달받는 함수 ```c int paf(int* a, int len) { int i; printf("배열 확인 : ["); for (i = 0; i < len;i++) { printf("%d", a[i]); if (i + 1 < len) { printf(","); } else { printf("]\n"); } } } void main() { int a[] = { 3,2,5,7,9 }; int si = sizeof(a)/4; paf(a,si); } // 출력 // 배열 확인 : [3,2,5,7,9] ```
변형 ```c int paf(int a[], int len) { int i; printf("배열 확인 : ["); for (i = 0; i < len;i++) { printf("%d", a[i]); //*(a+i)넣어도 됨 if (i + 1 < len) { printf(","); } else { printf("]\n"); } } } void main() { int a[] = { 3,2,5,7,9 }; int si = sizeof(a)/4; paf(a,si); } // 출력 // 배열 확인 : [3,2,5,7,9] ```

# 8월 23일 - 10일차 ### Call-by-Value, Call-by-reference 값을 받을경우 Call-by-Value ```c void sw(int n1, int n2) { int t = n1; n1 = n2; n2 = t; printf("sw함수 n1 = %d n2 = %d\n",n1,n2); } void main() { int a1 = 33, a2 = 99; sw(a1, a2); printf("main a1 = %d a2 = %d\n", a1, a2); } // 출력 // sw함수 n1 = 99 n2 = 33 main a1 = 33 a2 = 99 ``` 주소값을 받아서 변경 Call-by-reference ```c #include void sw(int* n1, int* n2) { int t = *n1; *n1 = *n2; *n2 = t; printf("sw함수 n1 = %d n2 = %d\n",*n1,*n2); } void main() { int a1 = 33, a2 = 99; sw(&a1, &a2); printf("main a1 = %d a2 = %d\n", a1, a2); } // 출력 // sw함수 n1 = 99 n2 = 33 main a1 = 99 a2 = 33 ```

# 8월 24일 - 11일차 ### 재귀호출함수 >함수가 몸체 내에서 자기 자신을 호출하는 것을 말함 ```c void sh () { printf("hello!\n"); sh(); } void main() { sh(); } // 출력 // 무한반복 ``` 반복통제 ```c int sh (int c) { printf("hello!\n"); if (c != 3) { sh(c + 1); } return 0; } void main() { sh(3); } // 출력 // hello! ``` 2회 출력 ```c int sh (int c) { printf("hello!\n"); if (c != 3) { sh(c + 1); } return 0; } void main() { sh(2); } // 출력 // hello! hello! ```
개수를 입력받아 반복실행 ```c #include int sh (int c) { if (c == 0) { return 0; } printf("hello!\n"); sh(c - 1); } void main() { sh(4); } // 출력 // hello! hello! hello! hello! ```
재귀함수 팩토리얼 값이 너무 크면 long long > 5! = 5x4x3x2x1 5\*(5-1)! n! = n \*(n-1)! ```c #include int ff (int n) { if (n == 1) { return 1; } return n * ff(n - 1); } void main() { printf("팩토리얼 %d = %d\n", 3, ff(3)); printf("팩토리얼 %d = %d\n", 5, ff(5)); printf("팩토리얼 %d = %d\n", 11, ff(11)); } // 출력 // 팩토리얼 3 = 6 팩토리얼 5 = 120 팩토리얼 11 = 39916800 ```
재귀함수 피보나치 수열 >피보나치 수열 간단히 첫달에는 새로태어난 토끼한쌍이 존재 두달 이상 되야 토끼번식 그다음 토끼 한쌍은 새끼 한쌍 번식 총 두쌍 네번째 달은 3쌍 다섯번째 달은 5쌍 피보나치 수열은 1:1.6의 황금비를 갖추고 있다. >f(1) = 1 f(2) = 1 f(n) = f(n-1)+f(n-2) 예 f(3) = 2, f(4) = 3, f(5) = 5, 8, 13, 21 > 단점 40을 넘으면 너무 느림 ```c int pf (int n) { if (n == 1 || n==2) { return 1; } else { return pf(n-1) + pf(n-2); } } void main() { for (int i = 1; i <= 20; i++) { printf("pf(%d) = %d\n", i, pf(i)); } } // 출력 // pf(1) = 1 pf(2) = 1 pf(3) = 2 pf(4) = 3 pf(5) = 5 pf(6) = 8 pf(7) = 13 pf(8) = 21 pf(9) = 34 pf(10) = 55 pf(11) = 89 pf(12) = 144 pf(13) = 233 pf(14) = 377 pf(15) = 610 pf(16) = 987 pf(17) = 1597 pf(18) = 2584 pf(19) = 4181 pf(20) = 6765 ```
일반 for문 피보나치 수열 ```c void main() { long long f1 = 0; long long f2 = 1; long long f3; for (int i = 1; i <= 50; i++) { if (i == 1) { printf("pf(%d) = %lld\n", i, f2); } else{ f3 = f1 + f2; printf("pf(%d) = %lld\n", i, f3); f1 = f2; f2 = f3; } } } ```

### 응용문제 #### 응용문제 1 >int형 변수 n1과 n2를 선언하고, 두 개의 인자를 전달받는 두 개의 함수를 정의해 보세요. 두 함수의 이름과 기능은 다음과 같습니다. >두 함수를 정의한 후 main함수에서 실행이 원활하게 되는지 확인해 보세요. cv : call-by-value 방식으로 두 수의 차를 구하여 반환하는 함수 (int) cr : call-by-reference 방식으로 두 수중에서 큰 것을 n1에, 작은것을 n2에 저장하는 함수 (void) (n1에 저장된 정수가 더 큰 경우 변화가 없으나, n2에 저장된 정수가 더 큰 경우 교환) ```c int cv(int n1, int n2) { return n1 - n2; } void cr(int *n1, int *n2) { int t; if (*n1 < *n2) { t = *n2; *n2 = *n1; *n1 = t; } } void main() { int n1 = 5, n2 = 10; printf("cv = %d\n", cv(n1, n2)); cr(&n1, &n2); printf("n1 = %d, n2 = %d\n", n1, n2); printf("cv = %d\n", cv(n1, n2)); } // 출력 // cv = -5 n1 = 10, n2 = 5 cv = 5 ```
#### 응용문제 2 >main함수가 작성된 상태에서 세 변수에 저장된 값을 서로 바꾸는 함수를 정의 호출 결과는 n1에 저장된 값은 n2에, n2에 저장된 값은 n3에, 그리고 n3에 저장된 값은 n1에 저장 >예 전 : 5 8 10 후 : 10 5 8 ```c #include void sn(int *n1, int *n2, int *n3) { int t = *n3; *n3 = *n2; *n2 = *n1; *n1 = t; } void main() { int n1 = 5, n2 = 8, n3 = 10; printf("전 : %d %d %d\n",n1,n2,n3); sn(&n1, &n2, &n3); printf("전 : %d %d %d\n",n1,n2,n3); } // 출력 // 전 : 5 8 10 전 : 10 5 8 ```
#### 응용문제 3 >main 함수가 다음과 같이 작성된 상태에서 1부터 n까지의 합을 구하여 반환하는 재귀 호출 함수 rs을 정의해 보세요. 0이 될 때까지 인자 값을 계속해서 더하는 방식 ```c int rs(int n) { if (n > 1) { return n + rs(n - 1); } else { return 1; } } void main() { int n = 10; int r = rs(n); printf("1부터 %d까지의 합 : %d", n, r); } // 출력 // 1부터 10까지의 합 : 55 ```

# 8월 25일 - 12일차 ### 종합문제 #### 종합문제 1 >rand() 함수에 의해 생성되는 난수 : 0 ~ 32767 >rand() 확인하여 0~10 범위로 생성 시키기 ```c #include #include int main() { for (int i = 0; i < 10; i++) { int r = rand()%11; printf("%d\n", r); } return 0; } ``` 고정값 변경 >srand(time(NULL)) ```c #include #include #include int main() { srand(time(NULL)); for (int i = 0; i < 10; i++) { int r = rand()%11; printf("%d\n", r); } return 0; } ```
#### 종합문제 2 > 생성된 난수를 맞추면 프로그램종료 1~10까지의 난수 생성 또는 0 입력시 종료 틀리면 난수 : x 후 다시 실행 ```c #include #include #include int main() { srand(time(NULL)); for (;;) { int a; int r = rand() % 10 + 1; printf("난수 맞춰(1~10) : "); scanf("%d", &a); if (a == r) { printf("정답입니다.\n"); return; } else if (a == 0) { printf("종료합니다\n"); return; } else { printf("틀렸습니다. 난수 : %d\n", r); } } return 0; } ```
#### 종합문제 2 - 2 > up and down a보다 작다. a보다 크다. 정답입니다. 0은 종료 ```c #include #include #include int main() { srand(time(NULL)); int r = rand() % 100 + 1; int a; for (;;) { printf("난수 맞춰(1~100) : "); scanf("%d", &a); if (a == r) { printf("정답입니다.\n"); return; } else if (a == 0) { printf("종료합니다\n"); return; } else if(a > r) { printf("%d 보다 작다.\n", a); } else if (a < r) { printf("%d 보다 크다.\n", a); } } return 0; } ```
#### 종합문제 3 가위바위보 게임을 만들기 규칙 가위 1, 바위 2, 보 3 사용자는 숫자를 입력 결과를 출력하기 가위바위보 게임은 함수로 제작 가위1 바위2 보3 : 2 당신은 바위, 컴퓨터는 바위 비겼습니다. 가위1 바위2 보3 : 2 당신은 바위, 컴퓨터는 가위 이겼습니다. ```c #include #include #include void game() { srand(time(NULL)); int r = rand() % 3 + 1; int a; char d[3][10] = { "가위","바위","보" }; printf("가위1 바위2 보3 : "); scanf("%d", &a); if (a == r) { printf("당신은 %s, 컴퓨터는 %s 비겼습니다.\n",d[a-1],d[r-1]); } else if (a%3 == (r + 1) % 3) { printf("당신은 %s, 컴퓨터는 %s 이겼습니다.\n", d[a-1], d[r-1]); } else if (a %3== (r + 2) % 3) { printf("당신은 %s, 컴퓨터는 %s 졌습니다.\n", d[a - 1], d[r - 1]); } } int main() { game(); game(); return 0; } // 출력 // 가위1 바위2 보3 : 2 당신은 바위, 컴퓨터는 보 졌습니다. 가위1 바위2 보3 : 1 당신은 가위, 컴퓨터는 가위 비겼습니다. ```
#### 종합문제 4 strcpy는 문자열관련 첫번째 인자의 주소에 두번째 인자로 전달된 주소의 문자열 값을 복사하는 함수 사용자 정의 함수로 동일한 기능을 수행하도록 작성하고 메인에서 호출하여 실행 ```c #include void strc(char* a, char* b) { for (int i = 0; ; i++) { b[i] = a[i]; if (a[i] == '\0') break; } } int main(){ char a[20] = "hello c"; char b[20]; strc(a, b); printf("%s", b); } ```

# 8월 28일 - 13일차 #### 종합문제 5 길이가 5인 int형 배열을 만들고, 사용자로부터 정수 5개를 입력받아 저장 배열을 오름차순 정렬 시키는 asc와 desc를 각각 정의하여 호출 ```c #include void asc(int* a) { for (int i = 0; i < 4; i++) { for (int j = 0; j < 4 - i;j++) { if (a[j] > a[j + 1]) { int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t; } } } } void asc2(int* a) { for (int i = 0; i < 4; i++) { for (int j = i+1; j < 5; j++) { if (a[i] > a[j]) { int t = a[i]; a[i] = a[j]; a[j] = t; } } } } void desc(int* a) { for (int i = 0; i < 4; i++) { for (int j = 0; j < 4 - i; j++) { if (a[j] < a[j + 1]) { int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t; } } } } int main(){ int a[5] = { 8,4,2,6,7 }; desc(a); for (int i = 0; i < 5; i++) { printf("%d ", a[i]); } } ``` ### 포인터 심화 #### 포인터의 포인터 포인터변수는 메모리 주솟값을 저장하는 변수 포인터 변수 또한 하나의 변수로 메모리공간을 차지하고 있음 포인터의 포인터를 저장하면 더블 포인터라고 함 >더블포인터 사용 ```c int n = 3; int * p = &n; int **dp = &p; ``` ```c int main() { int n = 3; int* p1 = &n; int** dp = &p1; int* p2 = *dp; printf("p1 = %p\np2 = %p\n*dp= %p\n&n = %p\n\n", p1, p2,*dp,&n); *p2 = 11; printf("n = %d, **dp = %d *p1 = %d", n, **dp, *p1); return 0; } // 출력 // p1 = 0000008B92F6FB94 p2 = 0000008B92F6FB94 *dp= 0000008B92F6FB94 &n = 0000008B92F6FB94 n = 11, **dp = 11 *p1 = 11 ```

##### 더블포인터의 Call-by-reference 함수를 호출할때 인자로 포인터 변수의 주소를 넣어줌 주소값이 바뀜 >n1 과 n2가 바뀐게 아니라 p1과 p2 즉 주소값이 변화 처음에는 p1 -> n1, p2 -> n2 함수실행후 p1 -> n2, p2 -> n1 ```c #include void sw(int** a, int** b) { int* t = *a; *a = *b; *b = t; } int main() { int n1 = 11, n2 = 9; int* p1 = &n1; int* p2 = &n2; printf("p1 = %p\np2 = %p\n\n", p1, p2); sw(&p1, &p2); printf("p1 = %p\np2 = %p\n\n", p1, p2); return 0; } // 출력 // p1 = 000000B6FB4FFB54 p2 = 000000B6FB4FFB74 p1 = 000000B6FB4FFB74 p2 = 000000B6FB4FFB54 ```

#### 함수 포인터 함수도 변수와 마찬가지로 메모리 주소가 존재 C언어는 함수의 주소를 저장할 수 있는 포인터 변수를 제공 이를 함수 포인터라 부름 >함수의 이름은 메모리 공간에 저장되어 있는 함수실행문의 시작 주소값임 ```c #include void mf(int a, int b) { printf("a : %d, b : %d\n", a, b); } int main() { int (*fp)(int, int) = mf; fp(10, 12); printf("%p\n", &mf); printf("%p\n", fp); return 0; } // 출력 // a : 10, b : 12 00007FF6D7BF1410 00007FF6D7BF1410 ```

#### void형 포인터 포인터 변수를 선언할때 자료형을 정의하지만 void로 지정할 수 있다. 어차피 주솟값을 저장하는 역활로 어떠한 주솟값도 저장할 수 있다. 하지만 type에 대한 정보가 없어서 포인터 연산이 불가능하다. 단순히 주솟값을 저장할 수 있는 의미만 있다.

#### 응용문제 ##### 응용문제 1 예측 ```c #include int main() { double v = 3.8; double* p = &v; double** dp = &p; printf("%0.1f\n", **dp); //v값 printf("%p\n", &dp); // dp주소 printf("%p\n", *&dp); // p주소 printf("%p\n", *dp); // v주소 printf("%p\n", &*dp); // p주소 printf("%p\n", &p); // p주소 return 0; } ```
##### 응용문제 2 예측 ```c #include int main() { int a = 33, b = 66; int* pa = &a; int* pb = &b; int** ppa = &pa; int** ppb = &pb; printf("%p %p %p %p\n", &a, &b, pa, pb); int* ptr; ptr = *ppb; //pb의 값(b의 주소값) *ppb = *ppa; //pa의 값(a의 주소값) *ppa = ptr; printf("%p %p %p %p\n", &a, &b, pa, pb); printf("%d %d %d %d\n", a, b, *pa, *pb); } // 출력 // 00000042B2AFF8A4 00000042B2AFF8C4 00000042B2AFF8A4 00000042B2AFF8C4 00000042B2AFF8A4 00000042B2AFF8C4 00000042B2AFF8C4 00000042B2AFF8A4 33 66 66 33 ```
##### 응용문제 3 다음과 같이 선언된 함수들에 대해서 대입 연산이 가능하도록 빈칸에 함수 포인터를 선언해 보세요.(함수 정의부 생략) ```c int FF(int a, int b); int SF(double d); int TF(char* c); int main() { int (*f)(int, int); int (*s)(double); int (*t)(char*); f = FF; s = SF; t = TF; return 0; } ```

## 메모리 관리, 구조체 ### 메모리 동적할당 > 힙영역 메모리 영역으로 데이터영역(전역변수), 스택영역(지역변수) 으로 되어 있는데 이는 변수의 생성과 소멸시점이 이미 정해져 있는 메모리 영역이다. 그러나 프로그램을 구현하다보면 생성과 소멸시점을 정해줄수 있는게 효율적일 수도 있다. 배열의 주소값을 반환하는 함수 ```c #include int* a() { int arr[] = {10,11}; return arr; } int main() { int* c = a(); printf("%d, %d", c[0],c[1]); return 0; } // 출력 // 10, 11 ``` char 배열 ```c char* a() { char st[50]; printf("좋아하는 단어 "); scanf("%s", st); printf("함수 실행 %s\n", st); return st; } int main() { char* c = a(); printf("%c%c%c%c\n", c[0], c[1], c[2], c[3]); printf("메인 실행 %s\n", c); printf("%c%c%c%c\n", c[0], c[1], c[2], c[3]); return 0; } // 출력 // 좋아하는 단어 asdfg 함수 실행 asdfg asdf 메인 실행 料? 料? ``` #### 메모리 동적할당 >프로그램이 실행되는 동안 사용할 메모리 공간을 할당하는 것이 메모리 동적할당임 >malloc함수 사용자가 생성과 소멸시기를 결정할 수 있는 변수를 선언할때 사용 > #include malloc(size) // 메모리 공간 크기를 바이트로 받음 > int * np = (int * )malloc(sizeof(int) * x) x만큼 메모리 할당 free(np); 메모리 해제 ```c char* a() { char* st = (char*)malloc(sizeof(char)*10); printf("좋아하는 단어 "); scanf("%s", st); printf("함수 실행 %s\n", st); return st; } int main() { char* c = a(); printf("메인 실행 %s\n", c); free(c); return 0; } // 출력 // 좋아하는 단어 카라멜마키아또 함수 실행 카라멜마키아또 메인 실행 카라멜마키아또 ```
>calloc calloc(개수, 크기) calloc은 할당하고자하는 메모리 공간의 개수와 각 메모리 공간별 크기를 전달받는다. 크기단위는 바이트이며 malloc과 마찬가지로 포인터로 반환 >malloc(sizeof(int) * 10) calloc(10,sizeof(int))
>realloc 목적이 다른함수로 힙영역에 할당되어 있는 메모리 공간의 크기를 조절하는 기능을 가짐 realroc(포인터, 새로운크기)

# 8월 29일 - 14일차 ```c #include #include int main() { int c = 0; int size = 3; int n; int* p = (int*)calloc(size,sizeof(int)); while (1) { printf("정수(-1종료) >> "); scanf("%d", &n); if (n == -1) { break; } if (c == size) { //없으면 에러 size += size; // 사이즈 +3 p = (int*)realloc(p, size * sizeof(int)); //증가 } p[c++] = n; } for (int i = 0; i < c; i++) { printf("%d ", p[i]); } free(p); return 0; } // 출력 // 정수(-1종료) >> 0 정수(-1종료) >> 1 정수(-1종료) >> 2 정수(-1종료) >> 3 정수(-1종료) >> 4 정수(-1종료) >> -1 0 1 2 3 4 ``` ##### 응용문제 1 ```c #include #include #include int main() { char* s1 = "Take a look!"; char* s2 = ; if (s2 != NULL) { free(s2); } return 0; } ``` 답 ```c #include #include #include int main() { char* s1 = "Take a look!"; int le = strlen(s1) + 1; char* s2 = (char*)malloc(sizeof(char) * le); for (int i = 0; i < le; i++) { s2[i] = s1[i]; } printf("%s\n", s2); if (s2 != NULL) { free(s2); } return 0; } // 출력 // Take a look! ``` 다른방법 ```c strcpy(s2, s1); ```
##### 응용문제 2 pa, pb, pc 중 할당영역이 가장큰 것은? ```c int main() { int arr[5] = { 10, 20, 30, 40, 50 }; int* pa; int* pb; int* pc; int i; pa = (int*)malloc(sizeof(arr)); for (i = 0; i < 5; i++) { pa[i] = arr[i]; } pb = (int*)calloc(pa[3], sizeof(int)); pc = (int*)realloc(NULL, pa[4]); return 0; } ``` 답안 ```c int main() { int arr[5] = { 10, 20, 30, 40, 50 }; // 5*4 =20 int* pa; int* pb; int* pc; int i; pa = (int*)malloc(sizeof(arr)); //20 for (i = 0; i < 5; i++) { pa[i] = arr[i]; } pb = (int*)calloc(pa[3], sizeof(int)); //40*4 = 160 pc = (int*)realloc(NULL, pa[4]); // 50 return 0; } ```
##### 응용문제 3 프로그램 사용자로부터 문자열의 최대 길이를 입력받고, 그만큼의 공간을 동적할당 받습니다. 그 다음 해당 공간에 저장할 문자열을 입력합니다. 이때 반드시 알파벳 소문자로만 구성된 문자열을 입력하고 입력한 문자열안에 알파벳 소문자 a가 몇 개나 포함되어 있는지 출력하는 프로그램을 작성해 보세요. 실행예 문자열의 최대 길이는 ? 50 문자열 입력 : hahaha a의 개수는 : 3개 입니다. hint, a의 아스키코드값은 97입니다. ```c int main() { int ml; printf("최대 길이? "); scanf("%d", &ml); char* s = (char*)malloc(sizeof(char)* ml); printf("문자열 입력 : "); scanf("%s", s); int si = strlen(s); int c = 0; for (int i = 0; i < si; i++) { if (s[i] == 97) { c++; } } printf("a의 개수는 : %d 입니다.",c); return 0; } // 출력 // 최대 길이? 20 문자열 입력 : aaahhhha a의 개수는 : 4 입니다. ```

## 구조체(Structure) 하나이상의 변수를 한번에 묶어서 사용 다른종류의 타입의 데이터를 저장할 수 있게됨 구조체를 구성하는 각 변수는 각각의 메모리 공간 할당, 구조체의 멤버로서 역할을 수행 사용자 정의 자료형이라 부른다 (사용자에 의해 정의) 메인함수 위에 정의 되어야 함 struct 키워드로 정의함 ```c struct p{ int a; char name[30]; }; ```
#### 구조체 선언 및 접근 ```c #include #include #include struct p{ int a; char name[30]; }; int main() { struct p a, b; strcpy(a.name, "백두산"); strcpy(b.name, "한라산"); a.a = 22; b.a = 33; printf("a 이름 : %s, 나이 : %d\n", a.name, a.a); printf("b 이름 : %s, 나이 : %d", b.name, b.a); return 0; } // 출력 // a 이름 : 백두산, 나이 : 22 b 이름 : 한라산, 나이 : 33 ```
#### 구조체 변수 초기화 ```c struct p{ int a; char name[30]; }; int main() { struct p a = { 30, "백두산" }; struct p b = { 22, "한라산" }; printf("a 이름 : %s, 나이 : %d\n", a.name, a.a); printf("b 이름 : %s, 나이 : %d", b.name, b.a); return 0; } // 출력 // a 이름 : 백두산, 나이 : 30 b 이름 : 한라산, 나이 : 22 ```

### 구조체와 배열 ```c struct p{ int a; char name[30]; }; int main() { struct p a[3] = { { 30, "백두산" }, { 22, "한라산" }, { 29, "지리산"} }; int si = sizeof(a) / sizeof(struct p); printf("%d\n", sizeof(struct p)); printf("%d\n", si); for (int i = 0; i < si; i++) { printf("a%d 이름 : %s, 나이 : %d\n", i,a[i].name, a[i].a); } return 0; } // 출력 // 36 3 a0 이름 : 백두산, 나이 : 30 a1 이름 : 한라산, 나이 : 22 a2 이름 : 지리산, 나이 : 29 ```

# 8월 30일 - 15일차 #### 입출력 받을수 있도록 생성 ```c #include #include #include struct p{ int a; char name[30]; }; int main() { struct p a[3]; int si = sizeof(a) / sizeof(struct p); for (int i = 0; i < si; i++) { printf("%d번째 이름 : ", i + 1); scanf("%s", a[i].name); printf("%d번째 나이 : ", i + 1); scanf("%d", &a[i].a); } for (int i = 0; i < si; i++) { printf("a%d 이름 : %s, 나이 : %d\n", i,a[i].name, a[i].a); } return 0; } // 출력 // 1번째 이름 : 백두산 1번째 나이 : 22 2번째 이름 : 한라산 2번째 나이 : 23 3번째 이름 : 지리산 3번째 나이 : 32 a0 이름 : 백두산, 나이 : 22 a1 이름 : 한라산, 나이 : 23 a2 이름 : 지리산, 나이 : 32 ```

### typedef 선언 기존에 존재하는 자료형에 새 이름을 부여 ```c typedef int i; typedef int* p; int main() { i a = 3; i b[] = { 10,20,30 }; p p1 = &a; p p2 = b; printf("%d\n", *p1); printf("%d", *(p2 + 1)); return 0; } // 출력 // 3 20 ```
#### 구조체와 typedef ```c struct p{ int a; char name[30]; }; typedef struct pp { int a; char name[20]; }PP; typedef struct p pst; int main() { pst a1 = { 22,"백두산" }; pst a2 = { 33, "한라산" }; PP b1 = { 25,"지리산" }; struct pp c1 = { 31, "설악산" }; printf("%d %s \n", a1.a, a1.name); printf("%d %s \n", a2.a, a2.name); printf("%d %s \n", b1.a, b1.name); printf("%d %s \n", c1.a, c1.name); return 0; } // 출력 // 22 백두산 33 한라산 25 지리산 31 설악산 ```

#### 응용문제 ##### 응용문제 1 원산지(or), 가격(pr),바리스타 이름(br)을 멤버로 갖는 coffee 구조체를 정의한 선언문 작성 문자열을 변수로 갖는 경우 문자열의 길이는 임의 ```c typedef struct coffee { char or[10]; int pr; char br[20]; }cf; int main() { cf a = { "케냐", 1000, "클라크" }; printf("원산지 %s, 가격 %d, 바리스타 이름 %s \n", a.or,a.pr,a.br); return 0; } // 출력 // 원산지 케냐, 가격 1000, 바리스타 이름 클라크 ```
##### 응용문제 2 직원 관리를 위한 구조체를 정의해 보세요. 문자열 형태의 이름, 문자열 형태의 전화번호, 정수 형태의 월급을 저장할 수 있는 worker라는 이름의 구조체를 정의하세요. 그리고 구조체변수를 하나 선언한 다음 프로그램 사용자가 직접 입력하는 정보로 변수를 채워 출력하세요. 입력예 직원의 이름 : 제임스 직원의 전화번호 : 010-1234-5678 직원의 월급여 : 1000000 실행예 직원의 이름 : 제임스 직원의 전화번호 : 010-1234-5678 직원의 월급여 : 1000000 ```c typedef struct worker { char n[20]; char pn[20]; int s; }w; int main() { w a; printf("이름 : "); scanf("%s", a.n); printf("전화번호 : "); scanf("%s", a.pn); printf("월급여 : "); scanf("%d", &a.s); printf("이름 : %s\n전화번호 %s\n월급여 %d", a.n,a.pn,a.s); return 0; } // 출력 // 이름 : 제임스 전화번호 : 010-1234-5678 월급여 : 10000000 이름 : 제임스 전화번호 010-1234-5678 월급여 10000000 ```
##### 응용문제 3 배열로 만들어서 저장한후 순서대로 출력 ```c typedef struct worker { char n[20]; char pn[20]; int s; }w; int main() { w a[3]; int si = sizeof(a) / sizeof(w); for (int i = 0; i < si; i++) { printf("%d 이름 : ",i+1); scanf("%s", a[i].n); printf("%d 전화번호 : ",i+1); scanf("%s", a[i].pn); printf("%d 월급여 : ",i+1); scanf("%d", &a[i].s); } for (int i = 0; i < si; i++) { printf("\n직원%d\n이름 : %s\n전화번호 %s\n월급여 %d\n", i+1,a[i].n, a[i].pn, a[i].s); } return 0; } // 출력 // 1 이름 : 백두산 1 전화번호 : 010-1234-5678 1 월급여 : 100 2 이름 : 설악산 2 전화번호 : 010-456-1234 2 월급여 : 200 3 이름 : 한라산 3 전화번호 : 010-789-1234 3 월급여 : 350 직원1 이름 : 백두산 전화번호 010-1234-5678 월급여 100 직원2 이름 : 설악산 전화번호 010-456-1234 월급여 200 직원3 이름 : 한라산 전화번호 010-789-1234 월급여 350 ```

### 구조체와 포인터 (\*p).age 이런형태와 p->age 동일 ```c typedef struct worker { char n[20]; int a; }p; int main() { p a = { "호날두", 38 }; p* p = &a; printf("%s(%d)\n", (*p).n, (*p).a); printf("%s(%d)\n", p->n, p->a); return 0; } // 출력 // 호날두(38) 호날두(38) ```
#### 구조체 멤버 변수로 선언된 포인터 변수 pi라는 구조체는 i라는 구조체 형태의 포인터를 갖는다 그리고 두가지의 포인터 변수를 저장할 수 있는 데이터형으로 변경 i형태로 만든 p1이라는 변수는 1,5의 값을 갖고 있고 p2는 10과 50의 변수를 갖고있다. pi라는 구조체에 p1변수와 p2변수의 주소를 넣어 포인터로 가르키면 1번째는 p1변수의 값을 2번째는 p2변수의 값을 가르킴 ```c typedef struct{ int a, b; }i; typedef struct { i* p1; i* p2; }pi; int main() { i p1 = { 1,5 }; i p2 = { 10,50 }; pi l = { &p1,&p2 }; printf("1번 [%d, %d]\n",l.p1->a,l.p1->b); printf("2번 [%d, %d]\n",l.p2->a,l.p2->b); return 0; } // 출력 // 1번 [1, 5] 2번 [10, 50] ```

### 구조체 중첩 구조체에 들어 있는 멤버로 다른 구조체를 사용할 수 있다. 기존에 선언되어 있는 구조체를 멤버변수로 선언할 수 있고 자기 자신의 변수까지도 사용할 수 있다. ```c typedef struct{ int a, b; }i; typedef struct { i i; int c; }i2; int main() { i2 a = { 10,50,999 }; printf("[%d, %d, %d]\n",a.i.a,a.i.b,a.c); return 0; } // 출력 // [10, 50, 999] ```
#### 구조체 배열 멤버변수 구조체를 중첩하는 기능에서, 배열형태로서도 작성 가능 ```c typedef struct{ int a, b; }i; typedef struct { i i[3]; int c; }i2; int main() { i2 a = { {{1,5},{10,50},{20,60}},999 }; int si = sizeof(a.i) / sizeof(i); for (int i = 0; i < si; i++) { printf("[%2d, %2d, %d]\n", a.i[i].a, a.i[i].b, a.c); } return 0; } // 출력 // [ 1, 5, 999] [10, 50, 999] [20, 60, 999] ```

### 구조체와 함수 구조체변수를 함수의 인자로 전달하고 반환도 가능함 ```c typedef struct{ int a, b; }ist; ist sint(int f1, int f2) { ist a = { f1, f2 }; return a; } void pr(ist a) { printf("[%d, %d]", a.a, a.b); } int main() { ist o = sint(10, 20); pr(o); return 0; } // 출력 // [10, 20] ```

#### 구조체와 Call-by-reference 큰값만 나올수 있도록 sp함수를 구성 포인터 a또는 b의 값(주소x)을 바꿔줌 ```c typedef struct{ int a, b; }i; void sp(i* p) { if (p->a > p->b) { p->b = p->a; } else { p->a = p->b; } } void pr(i a) { printf("[%d, %d]\n", a.a, a.b); } int main() { i a1 = { 1,20 }; i a2 = { 100, 10 }; sp(&a1); sp(&a2); pr(a1); pr(a2); return 0; } // 출력 // [20, 20] [100, 100] ```

#### 응용문제 ##### 응용문제1 다음과 같이 구조체 변수와 구조체 포인터를 선언시 p를 사용하여 구조체의 모든 변수를 출력 ```c typedef struct{ char n[30]; int a; double h; }ps; int main() { ps a = { "손오공", 30, 180.35}; ps* p = &a; printf("이름 : %s\n나이 : %d\n신장 : %.2f", p->n, p->a, p->h); return 0; } // 출력 // 이름 : 손오공 나이 : 30 신장 : 180.35 ```
##### 응용문제2 다음과 같은 구조체를 정의 두 멤버 변수를 대상으로 저장된 값을 서로 변형 이를 호출 1번째는 3,6 2번째는 4,9를 저장하고 있고 이 값을 변경하는 함수를 호출 ```c typedef struct { int x; int y; }in; void insw(in* a, in* b) { in c; c.x = a->x; c.y = a->y; a->x = b->x; a->y = b->y; b->x = c.x; b->y = c.y; } void main() { in a1 = { 3,6 }; in a2 = { 4,9 }; insw(&a1,&a2); printf("a1 x : %d, a1 y : %d\n", a1.x, a1.y); printf("a2 x : %d, a2 y : %d", a2.x, a2.y); } // 출력 // a1 x : 4, a1 y : 9 a2 x : 3, a2 y : 6 ```
##### 응용문제3 좌측 상단의 x, y좌표와 우측 하단의 x, y좌표를 가진 사각형 정보를 표현하기 위한 구조체 Rect를 정의합니다. 이 때 다음 구조체를 기반으로 정의해야 합니다. 멤버 변수로는 좌측상단과 우측하단 두개의 변수가 요구됩니다. ```c typedef struct { int x; int y; }pit; typedef struct { pit l; pit r; }rect; void prr(rect a) { int h = a.l.x - a.r.x; int w = a.l.y - a.r.y; if (h*w<0) { printf("사각형 넓이 : %d\n", -h * w); } else { printf("사각형 넓이 : %d\n", h * w); } } void main() { pit a1 = { 5,1 }; pit a2 = { 1,6 }; rect r = {a1,a2}; prr(r); } // 출력 // 사각형 넓이 : 20 ``` 절대값 함수 사용 ```c printf("사각형 넓이 : %d", abs(h * w)); ```

### 종합문제 ##### 종합문제 1 오름차순으로 정렬된 int형 배열과 int형 정수, 배열의 길이를 각각 인자로 전달 전달된 정수를 포함하는 새로운 오름차순 배열을 만들어 반환하는 createarr을 정의하고 호출해 보세요 이때 동적할당을 활용해 보세요 ```c int* ca(int* a, int n, int l) { int* na = (int*)malloc(sizeof(int)*(l+1)); na[l] = n; for (int i = 0; i < l; i++) { if (n > a[i]) { na[i] = a[i]; na[i + 1] = n; } else { na[i + 1] = a[i]; } if (n < a[0]) { na[0] = n; } } return na; } int main() { int a[3] = { 1,5,7 }; int len = sizeof(a) / sizeof(int); int n = 3; int* p; p = ca(a, n, len); for (int i = 0; i < len + 1; i++) { printf("%d ", p[i]); } } ```
##### 종합문제 2 길이가 동일한 두개의 배열을 인자로 받아 서로 값을 교환하는 함수 swapArr을 정의하고 호출해보기 ```c void swa(int* a, int* b, int l) { int* c = (int *)malloc(sizeof(int)*l); for (int i = 0; i < l; i++) { c[i] = a[i]; a[i] = b[i]; b[i] = c[i]; } free(c); } void main() { int a1[5] = { 1,3,5,7,9 }; int a2[5] = { 2,4,6,8,10 }; int len = sizeof(a1) / sizeof(int); swa(a1, a2, len); for (int i = 0; i < len; i++) { printf("%d ", a1[i]); } printf("\n"); for (int i = 0; i < len; i++) { printf("%d ", a2[i]); } } // 출력 // 2 4 6 8 10 1 3 5 7 9 ```

##### 종합문제 3 도서관리용 프로그램 제작 제목, 저자, 출간년도에 대한 구조체 정의 구조체 배열 선언해서 작성 사용자 정의함수로 저장구조 와 출력구조 정의 함수실행 제목 : c언어 저자 : 로버츠 출간년도 : 2023 제목 : c언어 저자 : 로버츠 출간년도 : 2023 ```c typedef struct { char bname[20]; char wt[20]; int py; }bp; void ib(bp* a) { printf("제목 : "); scanf("%s", a->bname); printf("저자 : "); scanf("%s", a->wt); printf("출간년도 : "); scanf("%d", &a->py); } void pb(bp* a, int b) { printf("\n", b); printf("제목 : %s\n", a->bname); printf("저자 : %s\n", a->wt); printf("출간년도 : %d\n", a->py); } int main() { bp a[3]; int si = sizeof(a) / sizeof(bp); for (int i = 0; i < si; i++) { ib(&a[i]); } for (int i = 0; i < si; i++) { pb(&a[i],i+1); } return 0; } // 출력 // 제목 : c언어 저자 : 로버츠 출간년도 : 2023 제목 : 자바 저자 : 콜린 출간년도 : 2021 제목 : 파이썬 저자 : 닉슨 출간년도 : 2022 제목 : c언어 저자 : 로버츠 출간년도 : 2023 제목 : 자바 저자 : 콜린 출간년도 : 2021 제목 : 파이썬 저자 : 닉슨 출간년도 : 2022 ```

게시글 상세