Ver3.0 ๐ฏ C์ธ์ด ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ stdio.h stdlib.h๋ฅผ ํ์ฉํ ๊ธฐ๋ณธ ์ ์ถ๋ ฅ ์ฒ๋ฆฌ

๐ฏ C์ธ์ด ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ stdio.h stdlib.h๋ฅผ ํ์ฉํ ๊ธฐ๋ณธ ์ ์ถ๋ ฅ ์ฒ๋ฆฌ
์น๊ตฌ์ฒ๋ผ ์ฝ๊ณ ์ฌ๋ฏธ์๊ฒ ๋ฐฐ์ฐ๋ C์ธ์ด ์ ์ถ๋ ฅ์ ๋ชจ๋ ๊ฒ! ๐ปโจ
๐ C์ธ์ด ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ, ์ ์ค์ํ ๊น?
์ผ, ์น๊ตฌ! C์ธ์ด ๊ณต๋ถํ๋ฉด์ ๊ฐ์ฅ ๋จผ์ ๋ง๋๊ฒ ๋๋ ๊ฒ ๋ญ์ง ์์? ๋ฐ๋ก #include <stdio.h>๋ผ๋ ๋
์์ด์ผ. ๐
์ฒ์ C์ธ์ด๋ฅผ ๋ฐฐ์ธ ๋ "Hello, World!"๋ฅผ ์ถ๋ ฅํ๋ ค๊ณ ํ๋ ๊ทธ ์๊ฐ์ ๊ธฐ์ตํด? ๊ทธ๋๋ถํฐ ์ฐ๋ฆฌ๋ ์ด๋ฏธ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ณ ์์๋ ๊ฑฐ์ผ. ๊ทผ๋ฐ ์ ์ ์ด๊ฒ ๋ญ์ง, ์ ํ์ํ์ง ์ ๋๋ก ์๊ณ ์ฐ๋ ์ฌ๋์ ๋ง์ง ์๋๋ผ๊ณ .
C์ธ์ด์ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๋งํ์๋ฉด ํ๋ก๊ทธ๋๋ฐ์ ๊ธฐ๋ณธ ๋๊ตฌ ์์์ผ. ์ง์ ์ง์ ๋ ๋ง์น, ํฑ, ๋๋ผ์ด๋ฒ๊ฐ ํ์ํ๋ฏ์ด, ํ๋ก๊ทธ๋จ์ ๋ง๋ค ๋๋ ๊ธฐ๋ณธ์ ์ธ ๋๊ตฌ๋ค์ด ํ์ํ๊ฑฐ๋ . ๊ทธ๊ฒ ๋ฐ๋ก ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ค์ด์๋ ํจ์๋ค์ด์ง!
ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ฌ๋ฌ ํค๋ ํ์ผ๋ก ๋๋์ด์ ธ ์์ด. ๊ฐ๊ฐ์ ํค๋ ํ์ผ์ ํน์ ๊ธฐ๋ฅ์ ๋ด๋นํ๋ ํจ์๋ค์ ๋ชจ์๋์ ๊ฑฐ์ง. ์ค๋ ์ฐ๋ฆฌ๊ฐ ์ง์ค์ ์ผ๋ก ๋ณผ ๊ฑด ๊ทธ์ค์์๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ stdio.h์ stdlib.h์ผ!
๐ stdio.h - ์ ์ถ๋ ฅ์ ์์๋
stdio.h๋ "Standard Input/Output Header"์ ์ฝ์์ผ. ์ด๋ฆ์์ ์ ์ ์๋ฏ์ด ํ์ค ์
์ถ๋ ฅ์ ๋ด๋นํ๋ ํค๋ ํ์ผ์ด์ง. ํ๋ก๊ทธ๋จ์ด ์ฌ์ฉ์์ ์ํตํ๋ ค๋ฉด ๋ฐ๋์ ํ์ํ ๋
์์ด์ผ! ๐ฌ
์๊ฐํด๋ด. ํ๋ก๊ทธ๋จ์ด ์๋ฌด๋ฆฌ ๋ณต์กํ ๊ณ์ฐ์ ํ๊ณ ๋ฉ์ง ์๊ณ ๋ฆฌ์ฆ์ ๋๋ ค๋, ๊ฒฐ๊ณผ๋ฅผ ํ๋ฉด์ ๋ณด์ฌ์ฃผ์ง ๋ชปํ๊ฑฐ๋ ์ฌ์ฉ์์ ์
๋ ฅ์ ๋ฐ์ง ๋ชปํ๋ค๋ฉด? ๊ทธ๊ฑด ๋ง์น ๋ง์ ๋ชปํ๋ ์ฒ์ฌ์ ๊ฐ์ ๊ฑฐ์ผ. ๋ต๋ตํ๊ฒ ์ง?
| ํจ์๋ช | ๊ธฐ๋ฅ | ์ฌ์ฉ ๋น๋ |
|---|---|---|
| printf() | ํ์ํ๋ ์ถ๋ ฅ | โญโญโญโญโญ |
| scanf() | ํ์ํ๋ ์ ๋ ฅ | โญโญโญโญโญ |
| getchar() | ๋ฌธ์ ํ๋ ์ ๋ ฅ | โญโญโญ |
| putchar() | ๋ฌธ์ ํ๋ ์ถ๋ ฅ | โญโญโญ |
| fgets() | ๋ฌธ์์ด ์ ๋ ฅ | โญโญโญโญ |
| fputs() | ๋ฌธ์์ด ์ถ๋ ฅ | โญโญโญ |
printf()๋ ์๋ง C์ธ์ด์์ ๊ฐ์ฅ ๋ง์ด ์ฐ๋ ํจ์์ผ ๊ฑฐ์ผ. "print formatted"์ ์ฝ์๋ก, ํ์์ ์ง์ ํด์ ์ถ๋ ฅํ ์ ์๋ค๋ ๋ป์ด์ง.
๊ธฐ๋ณธ ์ฌ์ฉ๋ฒ์ ์ด๋ ๊ฒ ์๊ฒผ์ด:
printf("ํ์ ๋ฌธ์์ด", ๋ณ์1, ๋ณ์2, ...);
์ฌ๊ธฐ์ ํต์ฌ์ ํ์ ์ง์ ์(format specifier)์ผ. ์ด๊ฒ ๋ญ๋๋ฉด, ๋ณ์์ ํ์ ์ ๋ฐ๋ผ ์ด๋ป๊ฒ ์ถ๋ ฅํ ์ง ์๋ ค์ฃผ๋ ํน์ ๋ฌธ์๋ค์ด์ง. ๐
%f - ์ค์(float, double) ์ถ๋ ฅ
%c - ๋ฌธ์(char) ์ถ๋ ฅ
%s - ๋ฌธ์์ด(string) ์ถ๋ ฅ
%p - ํฌ์ธํฐ ์ฃผ์ ์ถ๋ ฅ
%x - 16์ง์ ์ถ๋ ฅ
%o - 8์ง์ ์ถ๋ ฅ
%% - % ๊ธฐํธ ์์ฒด๋ฅผ ์ถ๋ ฅ
์ค์ ์์ ๋ฅผ ํ๋ฒ ๋ณผ๊น?
#include <stdio.h>
int main() {
int age = 25;
float height = 175.5;
char grade = 'A';
char name[] = "๊น์ฒ ์";
printf("์ด๋ฆ: %s\n", name);
printf("๋์ด: %d์ด\n", age);
printf("ํค: %.1f cm\n", height);
printf("ํ์ : %c\n", grade);
return 0;
}
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ์ด๋ ๊ฒ ๋์:
์ด๋ฆ: ๊น์ฒ ์
๋์ด: 25์ด
ํค: 175.5 cm
ํ์ : A
๊ทธ๋ฆฌ๊ณ printf()์ ๋ ๋ค๋ฅธ ๋ฉ์ง ๊ธฐ๋ฅ์ ํ๋ ํญ ์ง์ ์ด์ผ. ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ๊น๋ํ๊ฒ ์ ๋ ฌํ๊ณ ์ถ์ ๋ ์ฐ์ง:
#include <stdio.h>
int main() {
printf("%10s %5d %8.2f\n", "์ฌ๊ณผ", 100, 1500.5);
printf("%10s %5d %8.2f\n", "๋ฐ๋๋", 50, 2000.0);
printf("%10s %5d %8.2f\n", "ํฌ๋", 200, 3500.75);
return 0;
}
์ถ๋ ฅ:
์ฌ๊ณผ 100 1500.50
๋ฐ๋๋ 50 2000.00
ํฌ๋ 200 3500.75
๋ณด๊ธฐ ์ข๊ฒ ์ ๋ ฌ๋์ง? ํ๋ฅผ ๋ง๋ค ๋ ์ ๋ง ์ ์ฉํด! ๐
์ด์ ์
๋ ฅ์ ๋ฐ์๋ณผ ์ฐจ๋ก์ผ! scanf()๋ "scan formatted"์ ์ฝ์๋ก, ์ฌ์ฉ์๋ก๋ถํฐ ํ์ํ๋ ์
๋ ฅ์ ๋ฐ๋ ํจ์์ผ.
๊ธฐ๋ณธ ํํ๋ ์ด๋:
scanf("ํ์ ๋ฌธ์์ด", &๋ณ์1, &๋ณ์2, ...);
์ค์ ์์ ๋ฅผ ๋ณด์:
#include <stdio.h>
int main() {
int age;
float weight;
char initial;
printf("๋์ด๋ฅผ ์
๋ ฅํ์ธ์: ");
scanf("%d", &age);
printf("๋ชธ๋ฌด๊ฒ๋ฅผ ์
๋ ฅํ์ธ์: ");
scanf("%f", &weight);
printf("์ด๋ฆ์ ์ฒซ ๊ธ์๋ฅผ ์
๋ ฅํ์ธ์: ");
scanf(" %c", &initial); // ๊ณต๋ฐฑ ์ฃผ์!
printf("\n์
๋ ฅํ์ ์ ๋ณด:\n");
printf("๋์ด: %d์ด\n", age);
printf("๋ชธ๋ฌด๊ฒ: %.1fkg\n", weight);
printf("์ด๋์
: %c\n", initial);
return 0;
}
scanf()๋ ํธ๋ฆฌํ์ง๋ง ๋ฒํผ ์ค๋ฒํ๋ก์ฐ ๊ฐ์ ๋ณด์ ๋ฌธ์ ๊ฐ ์์ด. ๊ทธ๋์ ์์ฆ์ ๋ ์์ ํ ํจ์๋ค์ ์ฐ๋ ์ถ์ธ์ผ. ๊ทธ๊ฒ ๋ญ๋๊ณ ? ๋ฐ๋ก ๋ค์์ ๋์ฌ ํจ์๋ค์ด์ง!
fgets()๋ ๋ฌธ์์ด์ ์ ๋ ฅ๋ฐ์ ๋ scanf()๋ณด๋ค ํจ์ฌ ์์ ํด. ์๋ํ๋ฉด ์ต๋ ์ ๋ ฅ ๊ธธ์ด๋ฅผ ์ง์ ํ ์ ์๊ฑฐ๋ !
#include <stdio.h>
int main() {
char name[50];
printf("์ด๋ฆ์ ์
๋ ฅํ์ธ์: ");
fgets(name, sizeof(name), stdin);
printf("์๋
ํ์ธ์, %s", name);
return 0;
}
fgets()์ ์ฅ์ ์:
โ
๋ฒํผ ํฌ๊ธฐ๋ฅผ ์ง์ ํด์ ์ค๋ฒํ๋ก์ฐ ๋ฐฉ์ง
โ
๊ณต๋ฐฑ์ด ํฌํจ๋ ๋ฌธ์์ด๋ ์
๋ ฅ ๊ฐ๋ฅ
โ
๊ฐํ ๋ฌธ์๊น์ง ํฌํจํด์ ์ ์ฅ (ํ์ํ๋ฉด ์ ๊ฑฐ ๊ฐ๋ฅ)
๋จ์ ์ด๋ผ๋ฉด ๊ฐํ ๋ฌธ์(\n)๊น์ง ์ ์ฅ๋๋ค๋ ๊ฑฐ์ผ. ์ด๊ฑธ ์ ๊ฑฐํ๋ ค๋ฉด:
#include <stdio.h>
#include <string.h>
int main() {
char name[50];
printf("์ด๋ฆ์ ์
๋ ฅํ์ธ์: ");
fgets(name, sizeof(name), stdin);
// ๊ฐํ ๋ฌธ์ ์ ๊ฑฐ
name[strcspn(name, "\n")] = '\0';
printf("์๋
ํ์ธ์, %s๋!\n", name);
return 0;
}
๋๋ก๋ ๋ฌธ์ ํ๋์ฉ ์ฒ๋ฆฌํด์ผ ํ ๋๊ฐ ์์ด. ๊ทธ๋ด ๋ ์ฐ๋ ๊ฒ getchar()์ putchar()์ผ!
#include <stdio.h>
int main() {
char ch;
printf("๋ฌธ์๋ฅผ ์
๋ ฅํ์ธ์ (์ข
๋ฃ: Ctrl+D ๋๋ Ctrl+Z): \n");
while ((ch = getchar()) != EOF) {
if (ch >= 'a' && ch <= 'z') {
// ์๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก ๋ณํ
ch = ch - 'a' + 'A';
}
putchar(ch);
}
return 0;
}
์ด ํ๋ก๊ทธ๋จ์ ์ ๋ ฅ๋ฐ์ ์๋ฌธ์๋ฅผ ๋๋ฌธ์๋ก ๋ฐ๊ฟ์ ์ถ๋ ฅํด. ๊ฐ๋จํ์ง๋ง ๊ฐ๋ ฅํ ๊ธฐ๋ฅ์ด์ง! ๐ช
๐๏ธ stdlib.h - ์ ํธ๋ฆฌํฐ์ ๋ณด๋ฌผ์ฐฝ๊ณ
์, ์ด์ stdlib.h๋ฅผ ์์๋ณผ ์๊ฐ์ด์ผ! "Standard Library Header"์ ์ฝ์๋ก, ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํต์ฌ ์ ํธ๋ฆฌํฐ ํจ์๋ค์ด ๋ชจ์ฌ์๋ ๊ณณ์ด์ง.
stdio.h๊ฐ ์
์ถ๋ ฅ์ ํนํ๋์ด ์๋ค๋ฉด, stdlib.h๋ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ, ํ๋ก์ธ์ค ์ ์ด, ๋ฌธ์์ด ๋ณํ, ๋์ ์์ฑ ๋ฑ ๋ค์ํ ๊ธฐ๋ฅ์ ์ ๊ณตํด. ์ง์ง ๋ง๋ฅ ๋๊ตฌ ์์ ๊ฐ์ ๋๋์ด์ผ! ๐งฐ
ํ๋ก๊ทธ๋๋ฐ์ ํ๋ค ๋ณด๋ฉด ์คํ ์๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ผ๋ง๋ ํ์ํ ์ง ๋ชจ๋ฅผ ๋๊ฐ ๋ง์. ์๋ฅผ ๋ค์ด, ์ฌ์ฉ์๊ฐ ์
๋ ฅํ๋ ๋ฐ์ดํฐ์ ๊ฐ์๋ฅผ ๋ฏธ๋ฆฌ ์ ์ ์๋ค๋ฉด?
๊ทธ๋ด ๋ ์ฐ๋ ๊ฒ ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ด์ผ! ๐ฏ
calloc() - ๋ฉ๋ชจ๋ฆฌ ํ ๋น + 0์ผ๋ก ์ด๊ธฐํ
realloc() - ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ ์ฌ์กฐ์
free() - ๋ฉ๋ชจ๋ฆฌ ํด์
malloc()์ ๊ธฐ๋ณธ ์ฌ์ฉ๋ฒ์ ๋ณด์:
#include <stdio.h>
#include <stdlib.h>
int main() {
int n;
int *arr;
printf("๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์
๋ ฅํ์ธ์: ");
scanf("%d", &n);
// n๊ฐ์ ์ ์๋ฅผ ์ ์ฅํ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
arr = (int *)malloc(n * sizeof(int));
// ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์คํจ ์ฒดํฌ
if (arr == NULL) {
printf("๋ฉ๋ชจ๋ฆฌ ํ ๋น ์คํจ!\n");
return 1;
}
// ๋ฐฐ์ด์ ๊ฐ ์
๋ ฅ
printf("%d๊ฐ์ ์ ์๋ฅผ ์
๋ ฅํ์ธ์:\n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// ๋ฐฐ์ด ์ถ๋ ฅ
printf("์
๋ ฅํ ๊ฐ๋ค: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
// ๋ฉ๋ชจ๋ฆฌ ํด์ (์ค์!)
free(arr);
return 0;
}
calloc()์ malloc()๊ณผ ๋น์ทํ๋ฐ, ํ ๋นํ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๋์ผ๋ก 0์ผ๋ก ์ด๊ธฐํํด์ค:
#include <stdio.h>
#include <stdlib.h>
int main() {
int n = 5;
int *arr1, *arr2;
// malloc ์ฌ์ฉ
arr1 = (int *)malloc(n * sizeof(int));
printf("malloc์ผ๋ก ํ ๋นํ ๋ฐฐ์ด: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr1[i]); // ์ฐ๋ ๊ธฐ ๊ฐ
}
printf("\n");
// calloc ์ฌ์ฉ
arr2 = (int *)calloc(n, sizeof(int));
printf("calloc์ผ๋ก ํ ๋นํ ๋ฐฐ์ด: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr2[i]); // ๋ชจ๋ 0
}
printf("\n");
free(arr1);
free(arr2);
return 0;
}
realloc()์ ์ด๋ฏธ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ์ ํฌ๊ธฐ๋ฅผ ๋ฐ๊ฟ ๋ ์จ:
#include <stdio.h>
#include <stdlib.h>
int main() {
int *arr;
int size = 5;
// ์ฒ์์ 5๊ฐ ํฌ๊ธฐ๋ก ํ ๋น
arr = (int *)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
arr[i] = i + 1;
}
printf("์๋ ๋ฐฐ์ด: ");
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
// ํฌ๊ธฐ๋ฅผ 10์ผ๋ก ํ์ฅ
size = 10;
arr = (int *)realloc(arr, size * sizeof(int));
// ์๋ก ์ถ๊ฐ๋ ๋ถ๋ถ์ ๊ฐ ํ ๋น
for (int i = 5; i < size; i++) {
arr[i] = i + 1;
}
printf("ํ์ฅ๋ ๋ฐฐ์ด: ");
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
free(arr);
return 0;
}
๊ฒ์์ด๋ ์๋ฎฌ๋ ์ด์ ์ ๋ง๋ค ๋ ๋์(random number)๊ฐ ํ์ํ ๋๊ฐ ๋ง์. stdlib.h๋ ์ด๋ฅผ ์ํ ํจ์๋ค๋ ์ ๊ณตํด!
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
// ๋์ ์์ฑ๊ธฐ ์ด๊ธฐํ (ํ์ฌ ์๊ฐ์ ์๋๋ก ์ฌ์ฉ)
srand(time(NULL));
printf("์ฃผ์ฌ์๋ฅผ 5๋ฒ ๊ตด๋ฆฝ๋๋ค:\n");
for (int i = 0; i < 5; i++) {
int dice = rand() % 6 + 1; // 1~6 ์ฌ์ด์ ๋์
printf("๐ฒ %d\n", dice);
}
return 0;
}
rand()๋ 0๋ถํฐ RAND_MAX๊น์ง์ ๋์๋ฅผ ์์ฑํด. ํน์ ๋ฒ์์ ๋์๋ฅผ ์ป์ผ๋ ค๋ฉด ๋๋จธ์ง ์ฐ์ฐ์(%)๋ฅผ ํ์ฉํ๋ฉด ๋ผ!
srand()๋ ๋์ ์์ฑ๊ธฐ์ ์๋(seed)๋ฅผ ์ค์ ํ๋ ํจ์์ผ. ๊ฐ์ ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฐ์ ๋์ ์ํ์ค๊ฐ ๋์ค๊ธฐ ๋๋ฌธ์, ๋ณดํต time(NULL)์ ์๋๋ก ์ฌ์ฉํด์ ๋งค๋ฒ ๋ค๋ฅธ ๋์๋ฅผ ์ป์ด. โฐ
์์:
โข 1~100 ์ฌ์ด: rand() % 100 + 1
โข 10~20 ์ฌ์ด: rand() % 11 + 10
โข -5~5 ์ฌ์ด: rand() % 11 - 5
๋ฌธ์์ด์ ์ซ์๋ก, ์ซ์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํด์ผ ํ ๋๊ฐ ์์ด. stdlib.h๋ ์ด๋ฐ ๋ณํ ํจ์๋ค๋ ์ ๊ณตํด!
| ํจ์ | ๊ธฐ๋ฅ | ์์ |
|---|---|---|
| atoi() | ๋ฌธ์์ด โ ์ ์ | "123" โ 123 |
| atof() | ๋ฌธ์์ด โ ์ค์ | "3.14" โ 3.14 |
| atol() | ๋ฌธ์์ด โ long | "1234567890" โ 1234567890L |
| strtol() | ๋ฌธ์์ด โ long (๊ณ ๊ธ) | ์๋ฌ ์ฒดํฌ ๊ฐ๋ฅ |
| strtod() | ๋ฌธ์์ด โ double (๊ณ ๊ธ) | ์๋ฌ ์ฒดํฌ ๊ฐ๋ฅ |
#include <stdio.h>
#include <stdlib.h>
int main() {
char str1[] = "42";
char str2[] = "3.14159";
char str3[] = "100 apples";
int num1 = atoi(str1);
double num2 = atof(str2);
int num3 = atoi(str3); // ์ซ์ ๋ถ๋ถ๋ง ๋ณํ
printf("str1 '%s' โ %d\n", str1, num1);
printf("str2 '%s' โ %.5f\n", str2, num2);
printf("str3 '%s' โ %d\n", str3, num3);
// ๊ณ์ฐ์ ์ฌ์ฉ ๊ฐ๋ฅ
printf("\n๊ณ์ฐ ๊ฒฐ๊ณผ: %d + %.2f = %.2f\n",
num1, num2, num1 + num2);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main() {
char str[] = "12345abc";
char *endptr;
long num = strtol(str, &endptr, 10);
printf("๋ณํ๋ ์ซ์: %ld\n", num);
printf("๋ณํ ๋ฉ์ถ ์์น: %s\n", endptr);
if (*endptr != '\0') {
printf("โ ๏ธ ์์ ํ ๋ณํ ์คํจ! ์ซ์ ์๋ ๋ฌธ์ ๋ฐ๊ฒฌ\n");
}
return 0;
}
ํ๋ก๊ทธ๋จ์ ์ข ๋ฃํ ๋ ์ฌ์ฉํ๋ ํจ์๋ค๋ stdlib.h์ ์์ด!
#include <stdio.h>
#include <stdlib.h>
void cleanup() {
printf("ํ๋ก๊ทธ๋จ์ ์ ๋ฆฌํ๋ ์ค...\n");
printf("ํ์ผ์ ๋ซ๊ณ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํฉ๋๋ค.\n");
}
int main() {
// ํ๋ก๊ทธ๋จ ์ข
๋ฃ ์ ์๋์ผ๋ก ํธ์ถ๋ ํจ์ ๋ฑ๋ก
atexit(cleanup);
printf("ํ๋ก๊ทธ๋จ ์์!\n");
int age;
printf("๋์ด๋ฅผ ์
๋ ฅํ์ธ์: ");
scanf("%d", &age);
if (age < 0) {
printf("์๋ชป๋ ์
๋ ฅ์
๋๋ค!\n");
exit(1); // ์๋ฌ ์ฝ๋ 1๋ก ์ข
๋ฃ
}
printf("์
๋ ฅํ์ ๋์ด: %d์ด\n", age);
return 0; // ์ ์ ์ข
๋ฃ (exit(0)๊ณผ ๋์ผ)
}
exit()๋ ํ๋ก๊ทธ๋จ์ ์ฆ์ ์ข
๋ฃ์์ผ. 0์ ์ ์ ์ข
๋ฃ, 0์ด ์๋ ๊ฐ์ ์๋ฌ๋ฅผ ์๋ฏธํด.
atexit()๋ ํ๋ก๊ทธ๋จ์ด ์ข
๋ฃ๋ ๋ ์๋์ผ๋ก ์คํ๋ ํจ์๋ฅผ ๋ฑ๋กํ๋ ๊ฑฐ์ผ. ์ ๋ฆฌ ์์
(cleanup)์ ํ ๋ ์ ์ฉํด! ๐งน
abs()์ labs()๋ ์ ๋๊ฐ์ ๊ตฌํด:
#include <stdio.h>
#include <stdlib.h>
int main() {
int a = -42;
long b = -1234567890L;
printf("abs(%d) = %d\n", a, abs(a));
printf("labs(%ld) = %ld\n", b, labs(b));
return 0;
}
qsort()๋ ๋ฐฐ์ด์ ์ ๋ ฌํด์ฃผ๋ ๊ฐ๋ ฅํ ํจ์์ผ:
#include <stdio.h>
#include <stdlib.h>
// ๋น๊ต ํจ์
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
printf("์ ๋ ฌ ์ : ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
// ๋ฐฐ์ด ์ ๋ ฌ
qsort(arr, n, sizeof(int), compare);
printf("์ ๋ ฌ ํ: ");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
๐จ ์ค์ ํ๋ก์ ํธ - ํ์ ์ฑ์ ๊ด๋ฆฌ ํ๋ก๊ทธ๋จ
์, ์ด์ ๋ฐฐ์ด ๊ฑธ ์ข ํฉํด์ ์ค์ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ณด์! ํ์ ์ฑ์ ์ ๊ด๋ฆฌํ๋ ๊ฐ๋จํ ํ๋ก๊ทธ๋จ์ด์ผ. stdio.h์ stdlib.h์ ๋ค์ํ ํจ์๋ค์ ํ์ฉํ ๊ฑฐ์ผ! ๐
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_NAME 50
typedef struct {
char name[MAX_NAME];
int score;
} Student;
// ํ์ ์ ๋ณด ์
๋ ฅ
void inputStudent(Student *s) {
printf("ํ์ ์ด๋ฆ: ");
fgets(s->name, MAX_NAME, stdin);
s->name[strcspn(s->name, "\n")] = '\0';
printf("์ ์: ");
scanf("%d", &s->score);
getchar(); // ๋ฒํผ์ ๊ฐํ ๋ฌธ์ ์ ๊ฑฐ
}
// ํ์ ์ ๋ณด ์ถ๋ ฅ
void printStudent(const Student *s) {
printf("%-20s %3d์ ", s->name, s->score);
// ํ์ ๊ณ์ฐ
char grade;
if (s->score >= 90) grade = 'A';
else if (s->score >= 80) grade = 'B';
else if (s->score >= 70) grade = 'C';
else if (s->score >= 60) grade = 'D';
else grade = 'F';
printf(" (%cํ์ )\n", grade);
}
// ํ๊ท ๊ณ์ฐ
double calculateAverage(const Student *students, int count) {
int sum = 0;
for (int i = 0; i < count; i++) {
sum += students[i].score;
}
return (double)sum / count;
}
// ์ ๋ ฌ์ ์ํ ๋น๊ต ํจ์
int compareByScore(const void *a, const void *b) {
Student *s1 = (Student *)a;
Student *s2 = (Student *)b;
return s2->score - s1->score; // ๋ด๋ฆผ์ฐจ์
}
int main() {
int n;
Student *students;
printf("=== ํ์ ์ฑ์ ๊ด๋ฆฌ ํ๋ก๊ทธ๋จ ===\n\n");
printf("ํ์ ์๋ฅผ ์
๋ ฅํ์ธ์: ");
scanf("%d", &n);
getchar(); // ๋ฒํผ ๋น์ฐ๊ธฐ
// ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
students = (Student *)malloc(n * sizeof(Student));
if (students == NULL) {
printf("๋ฉ๋ชจ๋ฆฌ ํ ๋น ์คํจ!\n");
return 1;
}
// ํ์ ์ ๋ณด ์
๋ ฅ
printf("\nํ์ ์ ๋ณด๋ฅผ ์
๋ ฅํ์ธ์:\n");
for (int i = 0; i < n; i++) {
printf("\n[ํ์ %d]\n", i + 1);
inputStudent(&students[i]);
}
// ์ฑ์ ์์ผ๋ก ์ ๋ ฌ
qsort(students, n, sizeof(Student), compareByScore);
// ๊ฒฐ๊ณผ ์ถ๋ ฅ
printf("\n=== ์ฑ์ ๊ฒฐ๊ณผ (์ฑ์ ์) ===\n");
printf("%-20s %s\n", "์ด๋ฆ", "์ ์");
printf("----------------------------------------\n");
for (int i = 0; i < n; i++) {
printf("%2d. ", i + 1);
printStudent(&students[i]);
}
// ํต๊ณ ์ถ๋ ฅ
double avg = calculateAverage(students, n);
printf("\n----------------------------------------\n");
printf("ํ๊ท ์ ์: %.2f์ \n", avg);
printf("์ต๊ณ ์ ์: %d์ (%s)\n",
students[0].score, students[0].name);
printf("์ต์ ์ ์: %d์ (%s)\n",
students[n-1].score, students[n-1].name);
// ๋ฉ๋ชจ๋ฆฌ ํด์
free(students);
printf("\nํ๋ก๊ทธ๋จ์ ์ข
๋ฃํฉ๋๋ค.\n");
return 0;
}
์ด ํ๋ก๊ทธ๋จ์:
โ
malloc()์ผ๋ก ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
โ
fgets()๋ก ์์ ํ ๋ฌธ์์ด ์
๋ ฅ
โ
scanf()๋ก ์ซ์ ์
๋ ฅ
โ
printf()๋ก ํ์ํ๋ ์ถ๋ ฅ
โ
qsort()๋ก ๋ฐฐ์ด ์ ๋ ฌ
โ
free()๋ก ๋ฉ๋ชจ๋ฆฌ ํด์
๋ชจ๋ ๊ฑธ ์ข
ํฉํ ์๋ฒฝํ ์์ ์ผ! ๐ฏ
๐ง ์ค๋ฌด ํ๊ณผ ๋ฒ ์คํธ ํ๋ํฐ์ค
C์ธ์ด์ ์ ์ถ๋ ฅ์ ๋ฒํผ๋ฅผ ์ฌ์ฉํด. ๋ฒํผ๋ ๋ฐ์ดํฐ๋ฅผ ์์๋ก ์ ์ฅํ๋ ๊ณต๊ฐ์ธ๋ฐ, ์ด๊ฒ ๋๋ก๋ ๋ฌธ์ ๋ฅผ ์ผ์ผํฌ ์ ์์ด.
#include <stdio.h>
int main() {
int num;
char ch;
printf("์ซ์๋ฅผ ์
๋ ฅํ์ธ์: ");
scanf("%d", &num);
printf("๋ฌธ์๋ฅผ ์
๋ ฅํ์ธ์: ");
ch = getchar(); // ๋ฌธ์ ๋ฐ์!
printf("์
๋ ฅํ ๋ฌธ์: %c\n", ch);
return 0;
}
์ ์ฝ๋๋ ๋ฌธ์ ์
๋ ฅ์ ๊ฑด๋๋ฐ๋ ๋ฌธ์ ๊ฐ ์์ด. ์๋ํ๋ฉด scanf() ํ์ ๋ฒํผ์ ๊ฐํ ๋ฌธ์(\n)๊ฐ ๋จ์์๊ธฐ ๋๋ฌธ์ด์ง.
ํด๊ฒฐ ๋ฐฉ๋ฒ:
// ๋ฐฉ๋ฒ 1: getchar()๋ก ๋ฒํผ ๋น์ฐ๊ธฐ
scanf("%d", &num);
getchar(); // ๊ฐํ ๋ฌธ์ ์ ๊ฑฐ
ch = getchar();
// ๋ฐฉ๋ฒ 2: scanf()์์ ๊ณต๋ฐฑ ๋ฌด์
scanf("%d", &num);
scanf(" %c", &ch); // ๊ณต๋ฐฑ ์ถ๊ฐ
// ๋ฐฉ๋ฒ 3: ๋ฒํผ ์์ ํ ๋น์ฐ๊ธฐ
while (getchar() != '\n');
์ฌ์ฉ์ ์ ๋ ฅ์ ํญ์ ๊ฒ์ฆํด์ผ ํด! ์์์น ๋ชปํ ์ ๋ ฅ์ผ๋ก ํ๋ก๊ทธ๋จ์ด ๋ง๊ฐ์ง ์ ์๊ฑฐ๋ .
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// ์์ ํ ์ ์ ์
๋ ฅ ํจ์
int safeInputInt(const char *prompt, int min, int max) {
char buffer[100];
int value;
char *endptr;
while (1) {
printf("%s", prompt);
if (fgets(buffer, sizeof(buffer), stdin) == NULL) {
printf("์
๋ ฅ ์ค๋ฅ!\n");
continue;
}
// ๊ฐํ ๋ฌธ์ ์ ๊ฑฐ
buffer[strcspn(buffer, "\n")] = '\0';
// ๋ฌธ์์ด์ ์ ์๋ก ๋ณํ
value = strtol(buffer, &endptr, 10);
// ๋ณํ ์ฑ๊ณต ์ฌ๋ถ ํ์ธ
if (*endptr != '\0') {
printf("โ ์ซ์๋ง ์
๋ ฅํ์ธ์!\n");
continue;
}
// ๋ฒ์ ํ์ธ
if (value < min || value > max) {
printf("โ %d~%d ์ฌ์ด์ ๊ฐ์ ์
๋ ฅํ์ธ์!\n", min, max);
continue;
}
return value;
}
}
int main() {
int age = safeInputInt("๋์ด๋ฅผ ์
๋ ฅํ์ธ์ (1~120): ", 1, 120);
printf("โ
์
๋ ฅํ์ ๋์ด: %d์ด\n", age);
return 0;
}
stdio.h์ ํจ์๋ค์ ํ์ผ ์ ์ถ๋ ฅ์๋ ์ฌ์ฉ๋ผ. ํ์ค ์ ์ถ๋ ฅ๊ณผ ํ์ผ ์ ์ถ๋ ฅ์ ์ธํฐํ์ด์ค๊ฐ ๋น์ทํด์ ๋ฐฐ์ฐ๊ธฐ ์ฌ์!
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *fp;
char name[50];
int score;
// ํ์ผ์ ์ฐ๊ธฐ
fp = fopen("students.txt", "w");
if (fp == NULL) {
printf("ํ์ผ ์ด๊ธฐ ์คํจ!\n");
return 1;
}
printf("ํ์ ์ ๋ณด๋ฅผ ์
๋ ฅํ์ธ์ (์ข
๋ฃ: Ctrl+D)\n");
while (1) {
printf("์ด๋ฆ: ");
if (scanf("%s", name) != 1) break;
printf("์ ์: ");
if (scanf("%d", &score) != 1) break;
fprintf(fp, "%s %d\n", name, score); // printf์ ๋น์ท!
}
fclose(fp);
// ํ์ผ์์ ์ฝ๊ธฐ
fp = fopen("students.txt", "r");
if (fp == NULL) {
printf("ํ์ผ ์ด๊ธฐ ์คํจ!\n");
return 1;
}
printf("\n=== ์ ์ฅ๋ ํ์ ์ ๋ณด ===\n");
while (fscanf(fp, "%s %d", name, &score) == 2) { // scanf์ ๋น์ท!
printf("์ด๋ฆ: %s, ์ ์: %d\n", name, score);
}
fclose(fp);
return 0;
}
โข stdin - ํ์ค ์ ๋ ฅ (ํค๋ณด๋)
โข stdout - ํ์ค ์ถ๋ ฅ (ํ๋ฉด)
โข stderr - ํ์ค ์๋ฌ (ํ๋ฉด)
์ด๋ค๋ FILE* ํ์ ์ด๋ผ์ fprintf(), fscanf() ๊ฐ์ ํจ์๋ก ๋ค๋ฃฐ ์ ์์ด!
๐ฏ ์ฑ๋ฅ ์ต์ ํ์ ๊ณ ๊ธ ํ ํฌ๋
์ถ๋ ฅ ์ฑ๋ฅ์ ๋์ด๊ณ ์ถ๋ค๋ฉด ๋ฒํผ๋ง์ ์ ์ดํ ์ ์์ด:
#include <stdio.h>
#include <stdlib.h>
int main() {
// ๋ฒํผ ํฌ๊ธฐ ์ค์
char buffer[8192];
setvbuf(stdout, buffer, _IOFBF, sizeof(buffer));
// ๋๋์ ์ถ๋ ฅ
for (int i = 0; i < 10000; i++) {
printf("%d ", i);
}
// ๋ฒํผ ๊ฐ์ ๋น์ฐ๊ธฐ
fflush(stdout);
return 0;
}
printf()์ฒ๋ผ ์ธ์ ๊ฐ์๊ฐ ๊ฐ๋ณ์ ์ธ ํจ์๋ฅผ ๋ง๋ค ์๋ ์์ด:
#include <stdio.h>
#include <stdarg.h>
// ์ฌ๋ฌ ์ ์์ ํฉ์ ๊ตฌํ๋ ํจ์
int sum(int count, ...) {
va_list args;
va_start(args, count);
int total = 0;
for (int i = 0; i < count; i++) {
total += va_arg(args, int);
}
va_end(args);
return total;
}
// printf ์คํ์ผ์ ๋ก๊ทธ ํจ์
void myLog(const char *level, const char *format, ...) {
printf("[%s] ", level);
va_list args;
va_start(args, format);
vprintf(format, args); // printf์ ๊ฐ๋ณ ์ธ์ ๋ฒ์
va_end(args);
printf("\n");
}
int main() {
printf("ํฉ๊ณ: %d\n", sum(5, 1, 2, 3, 4, 5));
myLog("INFO", "ํ๋ก๊ทธ๋จ ์์");
myLog("ERROR", "ํ์ผ์ ์ฐพ์ ์ ์์ต๋๋ค: %s", "data.txt");
myLog("DEBUG", "๋ณ์ ๊ฐ: x=%d, y=%d", 10, 20);
return 0;
}
๐ ์ฌ๋ฅ๋ท์์ C์ธ์ด ์ค๋ ฅ ํค์ฐ๊ธฐ
C์ธ์ด๋ฅผ ๋
ํ์ผ๋ก ๊ณต๋ถํ๋ค ๋ณด๋ฉด ๋งํ๋ ๋ถ๋ถ์ด ์๊ธฐ๊ธฐ ๋ง๋ จ์ด์ผ. ํนํ ํฌ์ธํฐ, ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ, ๋ณต์กํ ์๋ฃ๊ตฌ์กฐ ๊ฐ์ ๊ฑด ํผ์ ์ดํดํ๊ธฐ ์ด๋ ค์ธ ์ ์์ด. ๐
๊ทธ๋ด ๋๋ ์ฌ๋ฅ๋ท(https://www.jaenung.net)์์ C์ธ์ด ์ ๋ฌธ๊ฐ์๊ฒ ๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ! 1:1 ์ฝ๋ ๋ฆฌ๋ทฐ๋ถํฐ ํ๋ก์ ํธ ๋ฉํ ๋ง๊น์ง ๋ค์ํ ์ฌ๋ฅ์ ๊ฑฐ๋ํ ์ ์๊ฑฐ๋ .
ํนํ ์ค๋ฌด์์ ์ฌ์ฉ๋๋ ์ฝ๋ฉ ์คํ์ผ์ด๋ ๋๋ฒ๊น
๊ธฐ๋ฒ ๊ฐ์ ๊ฑด ๊ฒฝํ ๋ง์ ๊ฐ๋ฐ์์๊ฒ ๋ฐฐ์ฐ๋ ๊ฒ ํจ์ฌ ๋น ๋ฅด๊ณ ํจ๊ณผ์ ์ด์ผ. ์ฌ๋ฅ๋ท์ '์ง์์ธ์ ์ฒ' ๊ฐ์ ๊ณณ์์ ๋ค์ํ ํ๋ก๊ทธ๋๋ฐ ์ง์๋ ์ป์ ์ ์๊ณ ! ๐
2๏ธโฃ ์ ์ด๋ฌธ๊ณผ ๋ฐ๋ณต๋ฌธ ๋ง์คํฐ
3๏ธโฃ ํจ์์ ๋ฐฐ์ด ํ์ฉ
4๏ธโฃ ํฌ์ธํฐ ์ ๋ณต (๊ฐ์ฅ ์ค์!)
5๏ธโฃ ๊ตฌ์กฐ์ฒด์ ๋์ ๋ฉ๋ชจ๋ฆฌ
6๏ธโฃ ํ์ผ ์ ์ถ๋ ฅ
7๏ธโฃ ์๋ฃ๊ตฌ์กฐ ๊ตฌํ
8๏ธโฃ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด
9๏ธโฃ ์ค์ ํ๋ก์ ํธ ๊ฐ๋ฐ
๐ ํํ ์ค์์ ๋๋ฒ๊น ํ
int x;
scanf("%d", x); // โ ์๋ชป๋จ
scanf("%d", &x); // โ
์ฌ๋ฐ๋ฆ
int *arr = (int *)malloc(100 * sizeof(int));
// ... ์ฌ์ฉ ...
// free(arr); ๋นผ๋จน์! โ
char name[10];
scanf("%s", name); // โ 10์ ์ด์ ์
๋ ฅํ๋ฉด ์ํ!
// ์์ ํ ๋ฐฉ๋ฒ:
fgets(name, sizeof(name), stdin); // โ
int *ptr = (int *)malloc(sizeof(int));
*ptr = 10; // โ malloc ์คํจ ์ ํฌ๋์!
// ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ:
int *ptr = (int *)malloc(sizeof(int));
if (ptr != NULL) { // โ
*ptr = 10;
}
#include <stdio.h>
#include <stdlib.h>
// ๋๋ฒ๊ทธ ๋งคํฌ๋ก
#ifdef DEBUG
#define DBG_PRINT(fmt, ...) \
printf("[DEBUG %s:%d] " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__)
#else
#define DBG_PRINT(fmt, ...)
#endif
int main() {
int x = 10;
int y = 20;
DBG_PRINT("๋ณ์ ์ด๊ธฐํ ์๋ฃ");
DBG_PRINT("x = %d, y = %d", x, y);
int result = x + y;
DBG_PRINT("๊ณ์ฐ ๊ฒฐ๊ณผ: %d", result);
return 0;
}
์ปดํ์ผํ ๋ -DDEBUG ์ต์ ์ ์ฃผ๋ฉด ๋๋ฒ๊ทธ ๋ฉ์์ง๊ฐ ์ถ๋ ฅ๋ผ:
gcc -DDEBUG program.c -o program
๐ stdio.h vs stdlib.h ๋น๊ต ์ ๋ฆฌ
| ๊ตฌ๋ถ | stdio.h | stdlib.h |
|---|---|---|
| ์ฃผ์ ๋ชฉ์ | ์ ์ถ๋ ฅ ์ฒ๋ฆฌ | ์ ํธ๋ฆฌํฐ ํจ์ |
| ๋ํ ํจ์ | printf, scanf, fgets | malloc, free, rand |
| ์ฌ์ฉ ๋น๋ | ๋งค์ฐ ๋์ | ๋์ |
| ํ์ต ๋์ด๋ | ์ฌ์ | ์ค๊ฐ |
| ํต์ฌ ๊ฐ๋ | ์คํธ๋ฆผ, ๋ฒํผ | ๋์ ๋ฉ๋ชจ๋ฆฌ, ๋ณํ |
๐ ์ค์ ์ฐ์ต ๋ฌธ์
์ด๋ก ๋ง ๊ณต๋ถํ๋ฉด ๊ธ๋ฐฉ ๊น๋จน์ด. ์ง์ ์ฝ๋๋ฅผ ์ง๋ณด๋ฉด์ ์ตํ์ผ ์ง์ง ์ค๋ ฅ์ด ๋์ด! ์ฌ๊ธฐ ๋ช ๊ฐ์ง ์ฐ์ต ๋ฌธ์ ๋ฅผ ์ค๋นํ์ด. ๐
โข scanf()๋ก ์ ๋ ฅ ๋ฐ๊ธฐ
โข printf()๋ก ๊ฒฐ๊ณผ ์ถ๋ ฅ
โข 0์ผ๋ก ๋๋๊ธฐ ์์ธ ์ฒ๋ฆฌ
โข malloc()์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ํ ๋น
โข qsort()๋ก ์ ๋ ฌ
โข free()๋ก ๋ฉ๋ชจ๋ฆฌ ํด์
โข srand()์ rand() ์ฌ์ฉ
โข ์ค๋ณต ์ฒดํฌ ๋ก์ง ๊ตฌํ
โข ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
โข fgets()๋ก ์์ ํ๊ฒ ์ ๋ ฅ
โข ๋ฌธ์ ๋ถ์ ๋ก์ง
โข ํต๊ณ ์ถ๋ ฅ
๐ญ ๋ง์น๋ฉฐ
์, ์ฌ๊ธฐ๊น์ง C์ธ์ด์ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ stdio.h์ stdlib.h๋ฅผ ํ์ฉํ ๊ธฐ๋ณธ ์
์ถ๋ ฅ ์ฒ๋ฆฌ์ ๋ํด ์์๋ดค์ด! ๐
์ฒ์์ ๋ณต์กํด ๋ณด์ผ ์ ์์ง๋ง, ํ๋์ฉ ์ฐจ๊ทผ์ฐจ๊ทผ ์ตํ๋ค ๋ณด๋ฉด ์ด๋์ ์์ฐ์ค๋ฝ๊ฒ ์ฌ์ฉํ๊ฒ ๋ ๊ฑฐ์ผ. ์ค์ํ ๊ฑด ์ง์ ์ฝ๋๋ฅผ ์ง๋ณด๋ ๊ฒ์ด์ผ. ๋ฐฑ ๋ฒ ์ฝ๋ ๊ฒ๋ณด๋ค ํ ๋ฒ ์ง์ ํ์ดํํด๋ณด๋ ๊ฒ ํจ์ฌ ํจ๊ณผ์ ์ด๊ฑฐ๋ ! ๐ช
๊ธฐ์ตํด:
โจ printf()์ scanf()๋ ๊ธฐ๋ณธ ์ค์ ๊ธฐ๋ณธ
โจ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ malloc()๊ณผ free()๋ฅผ ์ธํธ๋ก
โจ ์์ ํ ์
๋ ฅ์ ์ํด fgets() ํ์ฉ
โจ ์๋ฌ ์ฒ๋ฆฌ๋ ํ์!
โจ ๋ฒํผ ๊ด๋ฆฌ์ ์ฃผ์
C์ธ์ด๋ ์ค๋๋ ์ธ์ด์ง๋ง ์ฌ์ ํ ๊ฐ๋ ฅํ๊ณ ์ค์ํด. ์์คํ
ํ๋ก๊ทธ๋๋ฐ, ์๋ฒ ๋๋, ๊ฒ์ ์์ง ๋ฑ ๋ง์ ๊ณณ์์ ์ฌ์ฉ๋๊ณ ์๊ฑฐ๋ . ๊ธฐ์ด๋ฅผ ํํํ ๋ค์ ธ๋์ผ๋ฉด ๋์ค์ ์ด๋ค ์ธ์ด๋ฅผ ๋ฐฐ์ฐ๋ ์ฝ๊ฒ ์ ์ํ ์ ์์ด! ๐
ํน์ ๋ ๊น์ด ์๋ ํ์ต์ด๋ ํ๋ก์ ํธ ๋์์ด ํ์ํ๋ค๋ฉด, ์ฌ๋ฅ๋ท์์ ์ ๋ฌธ๊ฐ๋ค์ ๋์์ ๋ฐ์๋ณด๋ ๊ฒ๋ ์ข์ ์ ํ์ด์ผ. ํจ๊ป ์ฑ์ฅํ๋ ๊ฐ๋ฐ์๊ฐ ๋์! ๐
ํ์ดํ
! ๐ปโจ
๐ฏ Happy Coding! ๐ฏ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.