์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐ŸŽฏ C์–ธ์–ด ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์™€ stdio.h stdlib.h๋ฅผ ํ™œ์šฉํ•œ ๊ธฐ๋ณธ ์ž…์ถœ๋ ฅ ์ฒ˜๋ฆฌ

๐ŸŽฏ C์–ธ์–ด ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์™€ stdio.h stdlib.h๋ฅผ ํ™œ์šฉํ•œ ๊ธฐ๋ณธ ์ž…์ถœ๋ ฅ ์ฒ˜๋ฆฌ

์นœ๊ตฌ์ฒ˜๋Ÿผ ์‰ฝ๊ณ  ์žฌ๋ฏธ์žˆ๊ฒŒ ๋ฐฐ์šฐ๋Š” C์–ธ์–ด ์ž…์ถœ๋ ฅ์˜ ๋ชจ๋“  ๊ฒƒ! ๐Ÿ’ปโœจ

stdio.h printf scanf getchar stdlib.h malloc free exit C์–ธ์–ด ์ž…์ถœ๋ ฅ ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋กœ ์™„์„ฑํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์˜ ๊ธฐ์ดˆ

๐ŸŒŸ C์–ธ์–ด ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ, ์™œ ์ค‘์š”ํ• ๊นŒ?

์•ผ, ์นœ๊ตฌ! C์–ธ์–ด ๊ณต๋ถ€ํ•˜๋ฉด์„œ ๊ฐ€์žฅ ๋จผ์ € ๋งŒ๋‚˜๊ฒŒ ๋˜๋Š” ๊ฒŒ ๋ญ”์ง€ ์•Œ์•„? ๋ฐ”๋กœ #include <stdio.h>๋ผ๋Š” ๋…€์„์ด์•ผ. ๐Ÿ˜Š

์ฒ˜์Œ C์–ธ์–ด๋ฅผ ๋ฐฐ์šธ ๋•Œ "Hello, World!"๋ฅผ ์ถœ๋ ฅํ•˜๋ ค๊ณ  ํ–ˆ๋˜ ๊ทธ ์ˆœ๊ฐ„์„ ๊ธฐ์–ตํ•ด? ๊ทธ๋•Œ๋ถ€ํ„ฐ ์šฐ๋ฆฌ๋Š” ์ด๋ฏธ ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ์—ˆ๋˜ ๊ฑฐ์•ผ. ๊ทผ๋ฐ ์ •์ž‘ ์ด๊ฒŒ ๋ญ”์ง€, ์™œ ํ•„์š”ํ•œ์ง€ ์ œ๋Œ€๋กœ ์•Œ๊ณ  ์“ฐ๋Š” ์‚ฌ๋žŒ์€ ๋งŽ์ง€ ์•Š๋”๋ผ๊ณ .

C์–ธ์–ด์˜ ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋Š” ๋งํ•˜์ž๋ฉด ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๊ธฐ๋ณธ ๋„๊ตฌ ์ƒ์ž์•ผ. ์ง‘์„ ์ง€์„ ๋•Œ ๋ง์น˜, ํ†ฑ, ๋“œ๋ผ์ด๋ฒ„๊ฐ€ ํ•„์š”ํ•˜๋“ฏ์ด, ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค ๋•Œ๋„ ๊ธฐ๋ณธ์ ์ธ ๋„๊ตฌ๋“ค์ด ํ•„์š”ํ•˜๊ฑฐ๋“ . ๊ทธ๊ฒŒ ๋ฐ”๋กœ ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์— ๋“ค์–ด์žˆ๋Š” ํ•จ์ˆ˜๋“ค์ด์ง€!

๐Ÿ’ก ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ž€? C์–ธ์–ด ํ‘œ์ค€์—์„œ ์ •์˜ํ•œ ํ•จ์ˆ˜๋“ค์˜ ๋ชจ์Œ์ง‘์ด์•ผ. ์–ด๋–ค ์ปดํŒŒ์ผ๋Ÿฌ๋ฅผ ์“ฐ๋“ , ์–ด๋–ค ์šด์˜์ฒด์ œ์—์„œ ์‹คํ–‰ํ•˜๋“  ๋™์ผํ•˜๊ฒŒ ๋™์ž‘ํ•˜๋„๋ก ๋งŒ๋“ค์–ด์ง„ ํ•จ์ˆ˜๋“ค์ด์ง€. ์ด์‹์„ฑ(portability)์ด ๋›ฐ์–ด๋‚˜๋‹ค๋Š” ๊ฒŒ ๊ฐ€์žฅ ํฐ ์žฅ์ ์ด์•ผ! ๐Ÿš€

ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋Š” ์—ฌ๋Ÿฌ ํ—ค๋” ํŒŒ์ผ๋กœ ๋‚˜๋‰˜์–ด์ ธ ์žˆ์–ด. ๊ฐ๊ฐ์˜ ํ—ค๋” ํŒŒ์ผ์€ ํŠน์ • ๊ธฐ๋Šฅ์„ ๋‹ด๋‹นํ•˜๋Š” ํ•จ์ˆ˜๋“ค์„ ๋ชจ์•„๋†“์€ ๊ฑฐ์ง€. ์˜ค๋Š˜ ์šฐ๋ฆฌ๊ฐ€ ์ง‘์ค‘์ ์œผ๋กœ ๋ณผ ๊ฑด ๊ทธ์ค‘์—์„œ๋„ ๊ฐ€์žฅ ๊ธฐ๋ณธ์ด ๋˜๋Š” stdio.h์™€ stdlib.h์•ผ!

๐Ÿ“š stdio.h - ์ž…์ถœ๋ ฅ์˜ ์™•์ž๋‹˜

stdio.h๋Š” "Standard Input/Output Header"์˜ ์•ฝ์ž์•ผ. ์ด๋ฆ„์—์„œ ์•Œ ์ˆ˜ ์žˆ๋“ฏ์ด ํ‘œ์ค€ ์ž…์ถœ๋ ฅ์„ ๋‹ด๋‹นํ•˜๋Š” ํ—ค๋” ํŒŒ์ผ์ด์ง€. ํ”„๋กœ๊ทธ๋žจ์ด ์‚ฌ์šฉ์ž์™€ ์†Œํ†ตํ•˜๋ ค๋ฉด ๋ฐ˜๋“œ์‹œ ํ•„์š”ํ•œ ๋…€์„์ด์•ผ! ๐Ÿ’ฌ

์ƒ๊ฐํ•ด๋ด. ํ”„๋กœ๊ทธ๋žจ์ด ์•„๋ฌด๋ฆฌ ๋ณต์žกํ•œ ๊ณ„์‚ฐ์„ ํ•˜๊ณ  ๋ฉ‹์ง„ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ๋Œ๋ ค๋„, ๊ฒฐ๊ณผ๋ฅผ ํ™”๋ฉด์— ๋ณด์—ฌ์ฃผ์ง€ ๋ชปํ•˜๊ฑฐ๋‚˜ ์‚ฌ์šฉ์ž์˜ ์ž…๋ ฅ์„ ๋ฐ›์ง€ ๋ชปํ•œ๋‹ค๋ฉด? ๊ทธ๊ฑด ๋งˆ์น˜ ๋ง์„ ๋ชปํ•˜๋Š” ์ฒœ์žฌ์™€ ๊ฐ™์€ ๊ฑฐ์•ผ. ๋‹ต๋‹ตํ•˜๊ฒ ์ง€?

๐ŸŽฏ stdio.h์˜ ์ฃผ์š” ํ•จ์ˆ˜๋“ค
ํ•จ์ˆ˜๋ช… ๊ธฐ๋Šฅ ์‚ฌ์šฉ ๋นˆ๋„
printf() ํ˜•์‹ํ™”๋œ ์ถœ๋ ฅ โญโญโญโญโญ
scanf() ํ˜•์‹ํ™”๋œ ์ž…๋ ฅ โญโญโญโญโญ
getchar() ๋ฌธ์ž ํ•˜๋‚˜ ์ž…๋ ฅ โญโญโญ
putchar() ๋ฌธ์ž ํ•˜๋‚˜ ์ถœ๋ ฅ โญโญโญ
fgets() ๋ฌธ์ž์—ด ์ž…๋ ฅ โญโญโญโญ
fputs() ๋ฌธ์ž์—ด ์ถœ๋ ฅ โญโญโญ
โœจ printf() - ์ถœ๋ ฅ์˜ ๋งˆ๋ฒ•์‚ฌ

printf()๋Š” ์•„๋งˆ C์–ธ์–ด์—์„œ ๊ฐ€์žฅ ๋งŽ์ด ์“ฐ๋Š” ํ•จ์ˆ˜์ผ ๊ฑฐ์•ผ. "print formatted"์˜ ์•ฝ์ž๋กœ, ํ˜•์‹์„ ์ง€์ •ํ•ด์„œ ์ถœ๋ ฅํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๋œป์ด์ง€.

๊ธฐ๋ณธ ์‚ฌ์šฉ๋ฒ•์€ ์ด๋ ‡๊ฒŒ ์ƒ๊ฒผ์–ด:

printf("ํ˜•์‹ ๋ฌธ์ž์—ด", ๋ณ€์ˆ˜1, ๋ณ€์ˆ˜2, ...);

์—ฌ๊ธฐ์„œ ํ•ต์‹ฌ์€ ํ˜•์‹ ์ง€์ •์ž(format specifier)์•ผ. ์ด๊ฒŒ ๋ญ๋ƒ๋ฉด, ๋ณ€์ˆ˜์˜ ํƒ€์ž…์— ๋”ฐ๋ผ ์–ด๋–ป๊ฒŒ ์ถœ๋ ฅํ• ์ง€ ์•Œ๋ ค์ฃผ๋Š” ํŠน์ˆ˜ ๋ฌธ์ž๋“ค์ด์ง€. ๐Ÿ˜Ž

๐Ÿ”ค ์ฃผ์š” ํ˜•์‹ ์ง€์ •์ž %d - ์ •์ˆ˜(int) ์ถœ๋ ฅ
%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
๐Ÿ’ก Pro Tip! %.1f์ฒ˜๋Ÿผ ์†Œ์ˆ˜์  ์ž๋ฆฟ์ˆ˜๋ฅผ ์ง€์ •ํ•  ์ˆ˜ ์žˆ์–ด! %.2f๋Š” ์†Œ์ˆ˜์  ๋‘˜์งธ ์ž๋ฆฌ๊นŒ์ง€, %.3f๋Š” ์…‹์งธ ์ž๋ฆฌ๊นŒ์ง€ ์ถœ๋ ฅํ•˜๋Š” ๊ฑฐ์ง€. ์ •๋ฐ€ํ•œ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์—ฌ์ค„ ๋•Œ ์œ ์šฉํ•ด! ๐ŸŽฏ

๊ทธ๋ฆฌ๊ณ  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() - ์ž…๋ ฅ์˜ ๋‹ฌ์ธ

์ด์ œ ์ž…๋ ฅ์„ ๋ฐ›์•„๋ณผ ์ฐจ๋ก€์•ผ! scanf()๋Š” "scan formatted"์˜ ์•ฝ์ž๋กœ, ์‚ฌ์šฉ์ž๋กœ๋ถ€ํ„ฐ ํ˜•์‹ํ™”๋œ ์ž…๋ ฅ์„ ๋ฐ›๋Š” ํ•จ์ˆ˜์•ผ.

๊ธฐ๋ณธ ํ˜•ํƒœ๋Š” ์ด๋ž˜:

scanf("ํ˜•์‹ ๋ฌธ์ž์—ด", &๋ณ€์ˆ˜1, &๋ณ€์ˆ˜2, ...);
โš ๏ธ ์ฃผ์˜์‚ฌํ•ญ! scanf()์—์„œ๋Š” ๋ณ€์ˆ˜ ์•ž์— & ๊ธฐํ˜ธ๋ฅผ ๋ถ™์—ฌ์•ผ ํ•ด! ์ด๊ฑด ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๋ฅผ ์ „๋‹ฌํ•˜๋Š” ๊ฑฐ์•ผ. ๋ฌธ์ž์—ด(๋ฐฐ์—ด)์„ ์ž…๋ ฅ๋ฐ›์„ ๋•Œ๋Š” ์ด๋ฏธ ๋ฐฐ์—ด ์ด๋ฆ„ ์ž์ฒด๊ฐ€ ์ฃผ์†Œ๋‹ˆ๊นŒ &๋ฅผ ์•ˆ ๋ถ™์—ฌ๋„ ๋ผ. ์ด๊ฑฐ ํ—ท๊ฐˆ๋ฆฌ๋ฉด ์•ˆ ๋ผ! ๐Ÿšจ

์‹ค์ „ ์˜ˆ์ œ๋ฅผ ๋ณด์ž:

#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()์˜ ํ•จ์ •! ๋ฌธ์ž๋ฅผ ์ž…๋ ฅ๋ฐ›์„ ๋•Œ scanf(" %c", &initial)์ฒ˜๋Ÿผ %c ์•ž์— ๊ณต๋ฐฑ์„ ๋„ฃ๋Š” ๊ฒŒ ์ข‹์•„. ์™œ๋ƒํ•˜๋ฉด ์ด์ „ ์ž…๋ ฅ์—์„œ ๋‚จ์€ ๊ฐœํ–‰ ๋ฌธ์ž(\n)๋ฅผ ๋ฌด์‹œํ•˜๊ธฐ ์œ„ํ•ด์„œ์•ผ. ์ด๊ฑฐ ์•ˆ ํ•˜๋ฉด ์ž…๋ ฅ์„ ์ œ๋Œ€๋กœ ๋ชป ๋ฐ›๋Š” ๊ฒฝ์šฐ๊ฐ€ ์ƒ๊ฒจ! ๐Ÿ˜…

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๋Š” ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ฆฌ, ํ”„๋กœ์„ธ์Šค ์ œ์–ด, ๋ฌธ์ž์—ด ๋ณ€ํ™˜, ๋‚œ์ˆ˜ ์ƒ์„ฑ ๋“ฑ ๋‹ค์–‘ํ•œ ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•ด. ์ง„์งœ ๋งŒ๋Šฅ ๋„๊ตฌ ์ƒ์ž ๊ฐ™์€ ๋А๋‚Œ์ด์•ผ! ๐Ÿงฐ

๐Ÿ’พ ๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น - malloc()๊ณผ ์นœ๊ตฌ๋“ค

ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ํ•˜๋‹ค ๋ณด๋ฉด ์‹คํ–‰ ์‹œ๊ฐ„์— ๋ฉ”๋ชจ๋ฆฌ๊ฐ€ ์–ผ๋งˆ๋‚˜ ํ•„์š”ํ• ์ง€ ๋ชจ๋ฅผ ๋•Œ๊ฐ€ ๋งŽ์•„. ์˜ˆ๋ฅผ ๋“ค์–ด, ์‚ฌ์šฉ์ž๊ฐ€ ์ž…๋ ฅํ•˜๋Š” ๋ฐ์ดํ„ฐ์˜ ๊ฐœ์ˆ˜๋ฅผ ๋ฏธ๋ฆฌ ์•Œ ์ˆ˜ ์—†๋‹ค๋ฉด?

๊ทธ๋Ÿด ๋•Œ ์“ฐ๋Š” ๊ฒŒ ๋™์  ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น์ด์•ผ! ๐ŸŽฏ

๐Ÿ”‘ ์ฃผ์š” ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ฆฌ ํ•จ์ˆ˜ malloc() - ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น (Memory ALLOCation)
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;
}
โš ๏ธ ๋ฉ”๋ชจ๋ฆฌ ๋ˆ„์ˆ˜ ์ฃผ์˜! malloc()์œผ๋กœ ํ• ๋‹นํ•œ ๋ฉ”๋ชจ๋ฆฌ๋Š” ๋ฐ˜๋“œ์‹œ free()๋กœ ํ•ด์ œํ•ด์•ผ ํ•ด! ์•ˆ ๊ทธ๋Ÿฌ๋ฉด ๋ฉ”๋ชจ๋ฆฌ ๋ˆ„์ˆ˜(memory leak)๊ฐ€ ๋ฐœ์ƒํ•ด์„œ ํ”„๋กœ๊ทธ๋žจ์ด ์ ์  ๋А๋ ค์ง€๊ฑฐ๋‚˜ ์‹ฌํ•˜๋ฉด ์‹œ์Šคํ…œ์ด ๋‹ค์šด๋  ์ˆ˜๋„ ์žˆ์–ด. ์ด๊ฑด ์ •๋ง ์ค‘์š”ํ•œ ์Šต๊ด€์ด์•ผ! ๐Ÿšจ

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;
}
๐Ÿ’ก realloc() ์‚ฌ์šฉ ํŒ! realloc()์€ ๊ธฐ์กด ๋ฐ์ดํ„ฐ๋ฅผ ๋ณด์กดํ•˜๋ฉด์„œ ํฌ๊ธฐ๋ฅผ ์กฐ์ •ํ•ด์ค˜. ํ•˜์ง€๋งŒ ๋ฉ”๋ชจ๋ฆฌ ์œ„์น˜๊ฐ€ ๋ฐ”๋€” ์ˆ˜ ์žˆ์œผ๋‹ˆ๊นŒ ๋ฐ˜ํ™˜๊ฐ’์„ ๊ผญ ๋ฐ›์•„์•ผ ํ•ด! ๊ทธ๋ฆฌ๊ณ  realloc()์ด ์‹คํŒจํ•˜๋ฉด NULL์„ ๋ฐ˜ํ™˜ํ•˜๋Š”๋ฐ, ์ด๋•Œ ์›๋ณธ ํฌ์ธํ„ฐ์— ๋ฐ”๋กœ ๋Œ€์ž…ํ•˜๋ฉด ์›๋ณธ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ์žƒ์–ด๋ฒ„๋ฆฌ๋‹ˆ๊นŒ ์กฐ์‹ฌํ•ด์•ผ ํ•ด! ๐Ÿ˜ฑ
๐ŸŽฒ ๋‚œ์ˆ˜ ์ƒ์„ฑ - rand()์™€ srand()

๊ฒŒ์ž„์ด๋‚˜ ์‹œ๋ฎฌ๋ ˆ์ด์…˜์„ ๋งŒ๋“ค ๋•Œ ๋‚œ์ˆ˜(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)์„ ์‹œ๋“œ๋กœ ์‚ฌ์šฉํ•ด์„œ ๋งค๋ฒˆ ๋‹ค๋ฅธ ๋‚œ์ˆ˜๋ฅผ ์–ป์–ด. โฐ

๐ŸŽฏ ํŠน์ • ๋ฒ”์œ„์˜ ๋‚œ์ˆ˜ ์ƒ์„ฑ ๊ณต์‹ rand() % (max - min + 1) + min

์˜ˆ์‹œ:
โ€ข 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;
}
๐Ÿ’ก ๋” ์•ˆ์ „ํ•œ ๋ณ€ํ™˜ - strtol()๊ณผ strtod() atoi()๋‚˜ atof()๋Š” ๊ฐ„ํŽธํ•˜์ง€๋งŒ ์—๋Ÿฌ ์ฒ˜๋ฆฌ๊ฐ€ ์•ฝํ•ด. ๋ณ€ํ™˜์— ์‹คํŒจํ•ด๋„ ๊ทธ๋ƒฅ 0์„ ๋ฐ˜ํ™˜ํ•˜๊ฑฐ๋“ . ๋” ์•ˆ์ „ํ•œ ์ฝ”๋“œ๋ฅผ ์›ํ•œ๋‹ค๋ฉด strtol()์ด๋‚˜ strtod()๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒŒ ์ข‹์•„! ์ด ํ•จ์ˆ˜๋“ค์€ ๋ณ€ํ™˜์ด ์ œ๋Œ€๋กœ ๋๋Š”์ง€ ํ™•์ธํ•  ์ˆ˜ ์žˆ์–ด. ๐Ÿ›ก๏ธ
#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;
}
๐Ÿšช ํ”„๋กœ๊ทธ๋žจ ์ข…๋ฃŒ - exit()์™€ atexit()

ํ”„๋กœ๊ทธ๋žจ์„ ์ข…๋ฃŒํ•  ๋•Œ ์‚ฌ์šฉํ•˜๋Š” ํ•จ์ˆ˜๋“ค๋„ 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)์„ ํ•  ๋•Œ ์œ ์šฉํ•ด! ๐Ÿงน

๐Ÿ” ๊ธฐํƒ€ ์œ ์šฉํ•œ stdlib.h ํ•จ์ˆ˜๋“ค

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;
}
๐Ÿ’ก ํ‘œ์ค€ ์ŠคํŠธ๋ฆผ C์–ธ์–ด์—๋Š” 3๊ฐ€์ง€ ํ‘œ์ค€ ์ŠคํŠธ๋ฆผ์ด ์žˆ์–ด:
โ€ข 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 ์ฝ”๋“œ ๋ฆฌ๋ทฐ๋ถ€ํ„ฐ ํ”„๋กœ์ ํŠธ ๋ฉ˜ํ† ๋ง๊นŒ์ง€ ๋‹ค์–‘ํ•œ ์žฌ๋Šฅ์„ ๊ฑฐ๋ž˜ํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ .

ํŠนํžˆ ์‹ค๋ฌด์—์„œ ์‚ฌ์šฉ๋˜๋Š” ์ฝ”๋”ฉ ์Šคํƒ€์ผ์ด๋‚˜ ๋””๋ฒ„๊น… ๊ธฐ๋ฒ• ๊ฐ™์€ ๊ฑด ๊ฒฝํ—˜ ๋งŽ์€ ๊ฐœ๋ฐœ์ž์—๊ฒŒ ๋ฐฐ์šฐ๋Š” ๊ฒŒ ํ›จ์”ฌ ๋น ๋ฅด๊ณ  ํšจ๊ณผ์ ์ด์•ผ. ์žฌ๋Šฅ๋„ท์˜ '์ง€์‹์ธ์˜ ์ˆฒ' ๊ฐ™์€ ๊ณณ์—์„œ ๋‹ค์–‘ํ•œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์ง€์‹๋„ ์–ป์„ ์ˆ˜ ์žˆ๊ณ ! ๐Ÿ“š

๐ŸŽ“ C์–ธ์–ด ํ•™์Šต ๋กœ๋“œ๋งต 1๏ธโƒฃ ๊ธฐ๋ณธ ๋ฌธ๋ฒ•๊ณผ ์ž๋ฃŒํ˜• ์ดํ•ด
2๏ธโƒฃ ์ œ์–ด๋ฌธ๊ณผ ๋ฐ˜๋ณต๋ฌธ ๋งˆ์Šคํ„ฐ
3๏ธโƒฃ ํ•จ์ˆ˜์™€ ๋ฐฐ์—ด ํ™œ์šฉ
4๏ธโƒฃ ํฌ์ธํ„ฐ ์ •๋ณต (๊ฐ€์žฅ ์ค‘์š”!)
5๏ธโƒฃ ๊ตฌ์กฐ์ฒด์™€ ๋™์  ๋ฉ”๋ชจ๋ฆฌ
6๏ธโƒฃ ํŒŒ์ผ ์ž…์ถœ๋ ฅ
7๏ธโƒฃ ์ž๋ฃŒ๊ตฌ์กฐ ๊ตฌํ˜„
8๏ธโƒฃ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ ํ’€์ด
9๏ธโƒฃ ์‹ค์ „ ํ”„๋กœ์ ํŠธ ๊ฐœ๋ฐœ

๐Ÿ› ํ”ํ•œ ์‹ค์ˆ˜์™€ ๋””๋ฒ„๊น… ํŒ

โŒ ์ž์ฃผ ํ•˜๋Š” ์‹ค์ˆ˜๋“ค
1. scanf()์—์„œ & ๋นผ๋จน๊ธฐ
int x;
scanf("%d", x);  // โŒ ์ž˜๋ชป๋จ
scanf("%d", &x);  // โœ… ์˜ฌ๋ฐ”๋ฆ„
2. ๋ฉ”๋ชจ๋ฆฌ ํ•ด์ œ ์•ˆ ํ•˜๊ธฐ
int *arr = (int *)malloc(100 * sizeof(int));
// ... ์‚ฌ์šฉ ...
// free(arr); ๋นผ๋จน์Œ! โŒ
3. ๋ฒ„ํผ ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ
char name[10];
scanf("%s", name);  // โŒ 10์ž ์ด์ƒ ์ž…๋ ฅํ•˜๋ฉด ์œ„ํ—˜!

// ์•ˆ์ „ํ•œ ๋ฐฉ๋ฒ•:
fgets(name, sizeof(name), stdin);  // โœ…
4. NULL ํฌ์ธํ„ฐ ์ฒดํฌ ์•ˆ ํ•˜๊ธฐ
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
์‚ฌ์šฉ ๋นˆ๋„ ๋งค์šฐ ๋†’์Œ ๋†’์Œ
ํ•™์Šต ๋‚œ์ด๋„ ์‰ฌ์›€ ์ค‘๊ฐ„
ํ•ต์‹ฌ ๊ฐœ๋… ์ŠคํŠธ๋ฆผ, ๋ฒ„ํผ ๋™์  ๋ฉ”๋ชจ๋ฆฌ, ๋ณ€ํ™˜

๐Ÿš€ ์‹ค์ „ ์—ฐ์Šต ๋ฌธ์ œ

์ด๋ก ๋งŒ ๊ณต๋ถ€ํ•˜๋ฉด ๊ธˆ๋ฐฉ ๊นŒ๋จน์–ด. ์ง์ ‘ ์ฝ”๋“œ๋ฅผ ์งœ๋ณด๋ฉด์„œ ์ตํ˜€์•ผ ์ง„์งœ ์‹ค๋ ฅ์ด ๋Š˜์–ด! ์—ฌ๊ธฐ ๋ช‡ ๊ฐ€์ง€ ์—ฐ์Šต ๋ฌธ์ œ๋ฅผ ์ค€๋น„ํ–ˆ์–ด. ๐Ÿ˜Š

๐Ÿ“ ์—ฐ์Šต ๋ฌธ์ œ 1: ๊ณ„์‚ฐ๊ธฐ ํ”„๋กœ๊ทธ๋žจ ์‚ฌ์šฉ์ž๋กœ๋ถ€ํ„ฐ ๋‘ ์ˆซ์ž์™€ ์—ฐ์‚ฐ์ž(+, -, *, /)๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด๋ด.
โ€ข scanf()๋กœ ์ž…๋ ฅ ๋ฐ›๊ธฐ
โ€ข printf()๋กœ ๊ฒฐ๊ณผ ์ถœ๋ ฅ
โ€ข 0์œผ๋กœ ๋‚˜๋ˆ„๊ธฐ ์˜ˆ์™ธ ์ฒ˜๋ฆฌ
๐Ÿ“ ์—ฐ์Šต ๋ฌธ์ œ 2: ๋™์  ๋ฐฐ์—ด ๊ด€๋ฆฌ ์‚ฌ์šฉ์ž๊ฐ€ ์›ํ•˜๋Š” ํฌ๊ธฐ์˜ ๋ฐฐ์—ด์„ ๋™์ ์œผ๋กœ ์ƒ์„ฑํ•˜๊ณ , ๊ฐ’์„ ์ž…๋ ฅ๋ฐ›์•„ ์ •๋ ฌํ•œ ํ›„ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด๋ด.
โ€ข malloc()์œผ๋กœ ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น
โ€ข qsort()๋กœ ์ •๋ ฌ
โ€ข free()๋กœ ๋ฉ”๋ชจ๋ฆฌ ํ•ด์ œ
๐Ÿ“ ์—ฐ์Šต ๋ฌธ์ œ 3: ๋กœ๋˜ ๋ฒˆํ˜ธ ์ƒ์„ฑ๊ธฐ 1~45 ์‚ฌ์ด์˜ ์ค‘๋ณต๋˜์ง€ ์•Š๋Š” ๋žœ๋ค ์ˆซ์ž 6๊ฐœ๋ฅผ ์ƒ์„ฑํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด๋ด.
โ€ข srand()์™€ rand() ์‚ฌ์šฉ
โ€ข ์ค‘๋ณต ์ฒดํฌ ๋กœ์ง ๊ตฌํ˜„
โ€ข ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌ
๐Ÿ“ ์—ฐ์Šต ๋ฌธ์ œ 4: ๋ฌธ์ž์—ด ์ฒ˜๋ฆฌ ์‚ฌ์šฉ์ž๋กœ๋ถ€ํ„ฐ ๋ฌธ์žฅ์„ ์ž…๋ ฅ๋ฐ›์•„ ๋‹จ์–ด ๊ฐœ์ˆ˜, ๋ฌธ์ž ๊ฐœ์ˆ˜, ์ˆซ์ž ๊ฐœ์ˆ˜๋ฅผ ์„ธ๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด๋ด.
โ€ข fgets()๋กœ ์•ˆ์ „ํ•˜๊ฒŒ ์ž…๋ ฅ
โ€ข ๋ฌธ์ž ๋ถ„์„ ๋กœ์ง
โ€ข ํ†ต๊ณ„ ์ถœ๋ ฅ
์ž…๋ ฅ scanf C์–ธ์–ด ํ”„๋กœ๊ทธ๋žจ ์ถœ๋ ฅ printf ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋กœ ์™„์„ฑํ•˜๋Š” ์ž…์ถœ๋ ฅ์˜ ์„ธ๊ณ„

๐Ÿ’ญ ๋งˆ์น˜๋ฉฐ

์ž, ์—ฌ๊ธฐ๊นŒ์ง€ C์–ธ์–ด์˜ ํ‘œ์ค€ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ stdio.h์™€ stdlib.h๋ฅผ ํ™œ์šฉํ•œ ๊ธฐ๋ณธ ์ž…์ถœ๋ ฅ ์ฒ˜๋ฆฌ์— ๋Œ€ํ•ด ์•Œ์•„๋ดค์–ด! ๐ŸŽ‰

์ฒ˜์Œ์—” ๋ณต์žกํ•ด ๋ณด์ผ ์ˆ˜ ์žˆ์ง€๋งŒ, ํ•˜๋‚˜์”ฉ ์ฐจ๊ทผ์ฐจ๊ทผ ์ตํžˆ๋‹ค ๋ณด๋ฉด ์–ด๋А์ƒˆ ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ์‚ฌ์šฉํ•˜๊ฒŒ ๋  ๊ฑฐ์•ผ. ์ค‘์š”ํ•œ ๊ฑด ์ง์ ‘ ์ฝ”๋“œ๋ฅผ ์งœ๋ณด๋Š” ๊ฒƒ์ด์•ผ. ๋ฐฑ ๋ฒˆ ์ฝ๋Š” ๊ฒƒ๋ณด๋‹ค ํ•œ ๋ฒˆ ์ง์ ‘ ํƒ€์ดํ•‘ํ•ด๋ณด๋Š” ๊ฒŒ ํ›จ์”ฌ ํšจ๊ณผ์ ์ด๊ฑฐ๋“ ! ๐Ÿ’ช

๊ธฐ์–ตํ•ด:
โœจ printf()์™€ scanf()๋Š” ๊ธฐ๋ณธ ์ค‘์˜ ๊ธฐ๋ณธ
โœจ ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ฆฌ๋Š” malloc()๊ณผ free()๋ฅผ ์„ธํŠธ๋กœ
โœจ ์•ˆ์ „ํ•œ ์ž…๋ ฅ์„ ์œ„ํ•ด fgets() ํ™œ์šฉ
โœจ ์—๋Ÿฌ ์ฒ˜๋ฆฌ๋Š” ํ•„์ˆ˜!
โœจ ๋ฒ„ํผ ๊ด€๋ฆฌ์— ์ฃผ์˜

C์–ธ์–ด๋Š” ์˜ค๋ž˜๋œ ์–ธ์–ด์ง€๋งŒ ์—ฌ์ „ํžˆ ๊ฐ•๋ ฅํ•˜๊ณ  ์ค‘์š”ํ•ด. ์‹œ์Šคํ…œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ, ์ž„๋ฒ ๋””๋“œ, ๊ฒŒ์ž„ ์—”์ง„ ๋“ฑ ๋งŽ์€ ๊ณณ์—์„œ ์‚ฌ์šฉ๋˜๊ณ  ์žˆ๊ฑฐ๋“ . ๊ธฐ์ดˆ๋ฅผ ํƒ„ํƒ„ํžˆ ๋‹ค์ ธ๋†“์œผ๋ฉด ๋‚˜์ค‘์— ์–ด๋–ค ์–ธ์–ด๋ฅผ ๋ฐฐ์šฐ๋“  ์‰ฝ๊ฒŒ ์ ์‘ํ•  ์ˆ˜ ์žˆ์–ด! ๐Ÿš€

ํ˜น์‹œ ๋” ๊นŠ์ด ์žˆ๋Š” ํ•™์Šต์ด๋‚˜ ํ”„๋กœ์ ํŠธ ๋„์›€์ด ํ•„์š”ํ•˜๋‹ค๋ฉด, ์žฌ๋Šฅ๋„ท์—์„œ ์ „๋ฌธ๊ฐ€๋“ค์˜ ๋„์›€์„ ๋ฐ›์•„๋ณด๋Š” ๊ฒƒ๋„ ์ข‹์€ ์„ ํƒ์ด์•ผ. ํ•จ๊ป˜ ์„ฑ์žฅํ•˜๋Š” ๊ฐœ๋ฐœ์ž๊ฐ€ ๋˜์ž! ๐Ÿ˜Š

ํ™”์ดํŒ…! ๐Ÿ’ปโœจ

๐ŸŽฏ Happy Coding! ๐ŸŽฏ

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.