๋ฌธ์ž์—ด ์ €์žฅ/์ถœ๋ ฅ ์ฒ˜๋ฆฌ

#include <stdio.h>
 
int main() {
    char binary_data[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00, 0xFF, 0xFF}; 
    printf("%.*s\n", binary_data); 
    return 0;
}
 
// ์ถœ๋ ฅ: Hello

์—ฌ๊ธฐ์„œ %s๊ฐ€ ์ผ๋ฐ˜์ ์œผ๋กœ ๋ฌธ์ž์—ด ์ถœ๋ ฅ์„ ์œ„ํ•œ ๊ฑฐ๋ผ๊ณ  ํ•˜๋Š”๋ฐ, ์ฃผ์˜ํ•ด์•ผ ๋ ๊ฒƒ์ด
\0๋ฌธ์ž์—ด ์ฆ‰, ๋ฐ”์ด๋„ˆ๋ฆฌ ๊ฐ’์œผ๋กœ 0์ด ์กด์žฌํ•  ๊ฒฝ์šฐ ํ•ด๋‹น ๋ถ€๋ถ„ ๊นŒ์ง€๋งŒ ์ถœ๋ ฅ์ด ๋œ๋‹ค.

๋‹ค๋ฅธ ์–ธ์–ด๋“ค์—์„œ์ฒ˜๋Ÿผ ๋””๋ฒ„๊น… ๋ชฉ์ ์œผ๋กœ printf๋ฅผ ์‚ฌ์šฉํ•˜๋ ค๊ณ  ํ•  ๋•Œ ๋ฌธ์ œ๋Š” ๋ฐ”์ด๋„ˆ๋ฆฌ ๋ฐ์ดํ„ฐ๋ฅผ ๋ฌธ์ž์—ด๋กœ ์ถœ๋ ฅํ•˜๋ ค๊ณ  ์‹œ๋„ํ•  ๊ฒฝ์šฐ, \0(0x00)๊ฐ’์„ ๋งˆ์ฃผํ•œ๋‹ค๋ฉด ๋ฌธ์ž์—ด์ด ๋๋‚ฌ๋‹ค๊ณ  ํŒ๋‹จํ•˜์—ฌ ๋ฉˆ์ถฐ๋ฒ„๋ฆฐ๋‹ค.

๋งŒ์ผ \0์„ ํฌํ•จํ•˜์—ฌ ๋ชจ๋“ ๊ฒƒ์„ ์ถœ๋ ฅํ•˜๊ธธ ์›ํ•œ๋‹ค๋ฉด fwrite ๋ฅผ ์‚ฌ์šฉํ•˜์ž

#include <stdio.h>
 
int main() {
    char binary_data[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00, 0xFF, 0xFF}; 
    fwrite(binary_data, 1, sizeof(binary_data), stdout); 
    return 0;
}
 
// ์ถœ๋ ฅ: Hello??

๋‹น์—ฐํ•˜์ง€๋งŒ ์‹ค์ œ C์–ธ์–ด์—์„œ ๋ฌธ์ž์—ด์„ ๋‹ค๋ฃฐ๊ฒฝ์šฐ \0๊ฐ’์€ ์ทจ๊ธ‰ํ•˜์ง€ ์•Š๋Š”๋‹ค.
์ฐธ๊ณ ๋กœ ๋ฌธ์ž์—ด ์„ ์–ธ ์‹œ ์•„๋ž˜ ์ฒ˜๋Ÿผ ์„ ์–ธํ•œ ๊ฒฝ์šฐ ๋งจ ๋’ค์— \0์„ ์ž๋™ ์‚ฝ์ž…ํ•ด์ฃผ๋Š”๋ฐ

char str[] = "Hello, World!";

์•„๋ž˜์ฒ˜๋Ÿผ ์„ ์–ธํ•œ ๊ฒฝ์šฐ์—๋Š” ์‚ฝ์ž…๋˜์ง€ ์•Š์œผ๋ฏ€๋กœ ์ˆ˜๋™์œผ๋กœ \0์„ ์‚ฝ์ž…ํ•ด์•ผ ํ•œ๋‹ค.
์•ˆ ๊ทธ๋Ÿฌ๋ฉด ์‹คํ–‰ ์‹œ ์˜ฌ๋ฐ”๋ฅธ ๋ฌธ์ž์—ด ๋ฒ”์œ„๋ฅผ ํŒŒ์•…ํ•˜์ง€ ๋ชปํ•ด ์ด์ƒํ•œ ๊ฐ’์ด ์ €์žฅ๋œ๋‹ค.

char str[] = {'H', 'e', 'l', 'l', 'o'}; // ์ˆ˜๋™์œผ๋กœ ๋„ ์ข…๋ฃŒ

์Šคํƒ(Stack) ๋ณ€์ˆ˜, ํž™(Heap) ๋ณ€์ˆ˜

Stack

๋ฉ”๋ชจ๋ฆฌ์— Stack ์˜์—ญ์— ์ €์žฅ๋˜๋Š” ๋ณ€์ˆ˜
์‹ค์ œ ๋ฌผ๋ฆฌ์  ๋žจ๊ณผ ๊ฐ€์žฅ ๊ฐ€๊น๊ธฐ ๋•Œ๋ฌธ์— ๊ฐ€์žฅ ๋น ๋ฅธ ์†๋„๋ฅผ ์ง€๋‹˜
ํ•จ์ˆ˜ ํ˜ธ์ถœ ์‹œ ์ž๋™์œผ๋กœ ํ• ๋‹น๋˜๊ณ , ํ•ด์ œ๋จ

์Šคํƒ์˜์—ญ์€ ์ปดํŒŒ์ผ ํƒ€์ž„์—์„œ ํ• ๋‹น๋  ๋ฉ”๋ชจ๋ฆฌ์— ์ด๋Ÿ‰์ด ๊ณ„์‚ฐ๋œ๋‹ค.

์‹ค์ œ ๋ฉ”๋ชจ๋ฆฌ์—์„œ CPU์™€ ๊ฐ€๊น๊ฒŒ ์ž‘๋™ํ•˜๊ธฐ ์œ„ํ•ด์„œ ๋งŒ๋“ค์–ด์ง„ ๋ถ€๋ถ„์ด๋ผ ์šฉ๋Ÿ‰์ด ์ข€ ์ž‘์Œ

char buff[500];
int a;
# ์ด๊ฑฐ ๋ง๊ณ ๋„ ์ผ๋ฐ˜์ ์ธ short. charํ˜• ๋“ค๋„ ๋‹ค Stack ์˜์—ญ
  • ์ง€์—ญ์— ์„ ์–ธ๋œ ๊ฒฝ์šฐ ์ฃผ์†Œ๋ฅผ ๋ฆฌํ„ด ํ•  ๊ฒฝ์šฐ ํ•จ์ˆ˜๊ฐ€ ์ข…๋ฃŒ๋˜๋ฉด ํ• ๋‹น์„ ํ•ด์ œ ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์˜ค๋ฅ˜๊ฐ€ ๋‚œ๋‹ค
  • ์œ„์— ์˜ˆ์‹œ์ฒ˜๋Ÿผ ๋ฐฐ์—ด์—๋„ ๋˜‘๊ฐ™์ด ์ ์šฉ๋˜๋ฏ€๋กœ ํ˜น์—ฌ๋‚˜ ๋ฐฐ์—ด๋„ ํฌ์ธํ„ฐ ์ฒ˜๋Ÿผ ์“ฐ๋ฉด ๋˜
    ๋ผ๋Š” ์ธ์‹์œผ๋กœ ํ•จ์ˆ˜ ๋ฐ˜ํ™˜์„ ๋ฐฐ์—ด๋กœ ์ฃผ๋ฉด ์•ˆ๋œ๋‹ค.
  • ์ฆ‰ C์–ธ์–ด์—์„œ๋Š” ์ง€์—ญ๋ณ€์ˆ˜ ๋ฐฐ์—ด ๋ฐ˜ํ™˜์ด ์•ˆ๋œ๋‹ค.
  • ๋ฐฐ์—ด์— ๊ฒฝ์šฐ ๋”ฐ๋กœ Heap๋ณ€์ˆ˜๋กœ wapping ํ•ด์•ผ๋˜๊ณ (๋ฌธ์ž์—ด์— ๊ฒฝ์šฐ strcpy())
    ์ผ๋ฐ˜ ๋ณ€์ˆ˜๋Š” ์ตœ๋Œ€ํ•œ ๊ฐ’์œผ๋กœ ๋ฐ˜ํ™˜ํ•˜๋„๋ก ํ•ด์•ผ ํ•œ๋‹ค
    (์•„๋‹ˆ๋ฉด ์œ„์—์ฒ˜๋Ÿผ memcpy() ๋“ฑ์œผ๋กœ Heap๋ณ€์ˆ˜๋กœ wapping์ด ํ•„์š”)

๋ฐฐ์—ด์— ๋™์ ํ• ๋‹น์— ๋Œ€ํ•ด

์›๋ž˜ ๋ฐฐ์—ด์— ์ˆ˜๋ฅผ ์„ ์–ธํ• ๋–„๋Š” ๋ฌด์กฐ๊ฑด ์ ์œผ๋กœ ์ƒ์ˆ˜ ์ด๊ฑฐ๋‚˜, ์ˆซ์ž๋กœ๋งŒ ๊ฐ€๋Šฅํ–ˆ๋‹ค.
ํ•˜์ง€๋งŒ C11 ํ‘œ์ค€์—์„œ ๋ฐฐ์—ด ์ˆ˜ ์„ ์–ธ์‹œ ๋ณ€์ˆ˜๊ฐ€ ์‚ฌ์šฉ ๊ฐ€๋Šฅ ํ•˜๋„๋ก ํŒจ์น˜๋ฌ๋‹ค.

// ์ˆซ์ž ๋ฐฐ์—ด
int arr[100];
// ๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•œ ๋™์  ๋ฐฐ์—ด
int arr2[argc];

๊ทผ๋ฐ ๋ฌธ์ œ๋Š” MSVC๊ฐ€ ์ด๊ฑธ ์•„์ง๊นŒ์ง€๋„ ์ง€์› ์•ˆํ•œ๋‹ค.
GCC/LLVM ์‚ฌ์šฉ ์‹œ์—๋Š” ๊ฐ€๋Šฅํ•˜์ง€๋งŒ
๋งŒ์•ฝ ์œˆ๋„์šฐ ๊ฐœ๋ฐœ์„ ์œ„ํ•ด MSVC๋ฅผ ์‚ฌ์šฉํ•ด์•ผ๋˜๋ฉด ์ด๊ฑด ๋ฌด์กฐ๊ฑด ์•Œ์•„๋‘ฌ์•ผ ํ•œ๋‹ค.

์Šคํƒ๋ณ€์ˆ˜์— Undefined Behavior

์œ„์—์„œ ์Šคํƒ ๋ณ€์ˆ˜๋Š” ์•„๋ž˜์™€ ๊ฐ™์ด ํ•จ์ˆ˜์— ๋ฆฌํ„ด๊ฐ’์„ ํ•ด๋‹น ๋ณ€์ˆ˜์— ์ฃผ์†Œ๊ฐ’์œผ๋กœ ์ฃผ๋ฉด ์•ˆ๋œ๋‹ค๊ณ  ํ–ˆ๋Š”๋ฐ

์žฌ๋ฐŒ๋Š” ์ ์ด ์•„๋ž˜์ฒ˜๋Ÿผ ๋”ฐ๋กœ ํฌ์ธํ„ฐ ๋ณ€์ˆ˜ ์„ ์–ธ ํ›„ ํ•ด๋‹น ํฌ์ธํ„ฐ๋กœ ๊ฐ’์„ ์ „๋‹ฌํ•˜๋ฉด ์ „๋‹ฌ์ด ๋œ๋‹ค.

Test* stack(){
    Test test;
    Test *res = &test;
    return res;
}
 
void main() { 
    Test *test = stack();
}

์ด๊ฒƒ์€ Undefined Behavior(์ •์˜๋˜์ง€ ์•Š์€ ๋™์ž‘) ์ด๋‹ค

์ด๊ฒƒ์ด ์ž‘๋™ํ•˜๋Š” ์ด์œ ๋Š” 2๊ฐ€์ง€ ์ธ๋ฐ

๋จผ์ € ์ฒซ๋ฒˆ์งธ๋กœ ํฌ์ธํ„ฐ ๋ณ€์ˆ˜๋Š” ์Šคํƒ, ํž™ ์˜์—ญ ๋ชจ๋‘์—์„œ ์กด์žฌํ•  ์ˆ˜ ์žˆ๋‹ค.
์ฆ‰ Test *res๋Š” ์Šคํƒ์˜์—ญ/ํž™ ์˜์—ญ๊ณผ ์ƒ๊ด€์—†์ด ์–ด๋””์„œ๋“  ์“ธ ์ˆ˜ ์žˆ๋‹ค
ํฌ์ธํ„ฐ ๋ณ€์ˆ˜๋Š” ์Šคํƒ์˜์—ญ์— ํ• ๋‹น ํ•ด์ œ ํ•˜๊ณ ๋Š” ์ƒ๊ด€์ด ์—†๋Š”๊ฒƒ์ด๋‹ค.

ํฌ์ธํ„ฐ ๋ณ€์ˆ˜ ์—†์ด &test ๋กœ ๋ฐ”๋กœ ์ฃผ์†Œ๋ฅผ ๋ฐ˜ํ™˜ ํ•ด๋ฒ„๋ฆฌ๋ฉด Segmentation Fault ์• ๋Ÿฌ๊ฐ€ ๋‚œ๋‹ค.
๊ทผ๋ฐ ํฌ์ธํ„ฐ๋กœ ๊ฐ’์„ mapping ํ•ด์„œ ์ „๋‹ฌํ•˜๋ฉด ํฌ์ธํ„ฐ ๋ณ€์ˆ˜ ์ž์ฒด๋Š” ํ• ๋‹นํ•ด์ง€ ๋˜์ง€์•Š๊ณ  ์ •์ƒ ์ ์œผ๋กœ ๋ฐ˜ํ™˜๋˜๊ธฐ์— ์• ๋Ÿฌ๊ฐ€ ์•ˆ๋‚˜๋Š” ๊ฒƒ์ด๋‹ค

๋‘๋ฒˆ์งธ๋Š” ํ”„๋กœ๊ทธ๋žจ ๋™์ž‘์ด ํฌ๊ฒŒ ๋ณต์žกํ•˜์ง€ ์•Š๋Š” ๊ฒฝ์šฐ ํ•จ์ˆ˜๊ฐ€ ๋ฐ˜ํ™˜๋˜์–ด ํ• ๋‹น ํ•ด์ œ ๋˜์–ด๋„
๋‹ค๋ฅธ ์Šคํƒ ์˜์—ญ์—์„œ ํ•ด๋‹น ์˜์—ญ์„ ๋ฎ์–ด์“ฐ์ง€ ์•Š์•˜๋‹ค๋ฉด
์ •์ƒ์ ์œผ๋กœ ๊ฐ’์„ ๋ถˆ๋Ÿฌ์˜ฌ ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ด๋‹ค.

์ฆ‰ ์ •์ƒ์ ์ธ ์ƒํ™ฉ์€ ์•„๋‹ˆ๊ณ  ์ด๋Ÿฐ ์ฝ”๋“œ๋กœ ์ธํ•ด ์ถ”ํ›„ ๋ฌธ์ œ๊ฐ€ ์ƒ๊ธธ ์ˆ˜ ์žˆ๋‹ค.

Heap

๋ฉ”๋ชจ๋ฆฌ์— Heap ์˜์—ญ์— ์ €์žฅ๋˜๋Š” ๋ณ€์ˆ˜
Stack์˜์—ญ ๋ณด๋‹ค๋Š” ์ƒ๋Œ€์ ์œผ๋กœ ๋А๋ฆฌ๊ฒŒ ์ž‘๋™
ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ์ง์ ‘ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํ• ๋‹นํ•˜๊ณ , ํ•ด์ œ ํ•ด์•ผ ํ•จ

์‚ฌ์‹ค์ƒ ์ผ๋ฐ˜์ ์œผ๋กœ ๋žจ์ด ์‚ฌ์šฉํ•˜๋Š” ์˜์—ญ์„ ๊ฐ€๋ฅดํ‚ด

ํž™ ํ• ๋‹น์€ ๋Ÿฐํƒ€์ž„์—์„œ ๋™์ ์œผ๋กœ ํ• ๋‹น์ด ๋จ, ๊ทธ๋ž˜์„œ ๋ฉ”๋ชจ๋ฆฌ ๋™์ ํ• ๋‹น ์ด๋ผ๊ณ ๋„ ํ•จ

์˜คํ•ดํ•˜๋ฉด ์•ˆ๋˜๋Š”๊ฒŒ ๊ตฌ์กฐ์ฒด ๋“ฑ์—์„œ ์ดˆ๊ธฐํ™”๋ฅผ ํ•  ์‹œ ํ•ด๋‹น ๊ตฌ์กฐ์ฒด์˜ ํ•„์š”ํ•œ ํฌ๊ธฐ๋งŒํผ ๊ณต๊ฐ„์„ ํ• ๋‹นํ•˜๊ฒ ๋‹ค๋Š” ๊ฑฐ๋ผ์„œ ์˜ˆ๋ฅผ๋“ค์–ด ์ด๊ฒƒ์„ ๋™์ ๋ฆฌ์ŠคํŠธ์ฒ˜๋Ÿผ ์‚ฌ์šฉํ•œ๋‹ค๊ฑฐ๋‚˜ ํ•˜๋Š”๊ฒƒ์€ ์•ˆ๋จ

  • Heap ๋ณ€์ˆ˜๋งŒ ํ• ๋‹น ๋’ค free()๋กœ ํ•ด์ œ ํ•ด์•ผ ํ•จ
char *buff = (char *)malloc(500);

๊ตฌ์กฐ์ฒด์˜ ๊ฒฝ์šฐ

๊ตฌ์กฐ์ฒด๋ฅผ malloc ์œผ๋กœ ์ดˆ๊ธฐํ™” ํ•œ ๊ฒฝ์šฐ ๋ฉ”๋ชจ๋ฆฌ์— ๊ตฌ์กฐ์ฒด ๋ณ€์ˆ˜๊ฐ€ ์„ ์–ธ๋œ ์ˆœ์„œ๋Œ€๋กœ ์ €์žฅ๋œ๋‹ค.
์ด๊ฒŒ ๊ต‰์žฅํžˆ ์ค‘์š”ํ•œ๊ฒŒ malloc์œผ๋กœ ์ดˆ๊ธฐํ™”๋œ ๊ตฌ์กฐ์ฒด ๋‚ด๋ถ€ ๋ณ€์ˆ˜๊ฐ’์˜ ์ฃผ์†Œ๊ฐ’์„ ์•Œ๊ณ  ์žˆ๋‹ค๋ฉด, ํ•ด๋‹น๋ณ€์ˆ˜๋ฅผ ๊ตฌ์กฐ์ฒด ํฌ์ธํ„ฐ๋กœ ๋ณ€ํ™˜ํ•˜์—ฌ, ๊ตฌ์กฐ์ฒด ๋‚ด๋ถ€ ๋ชจ๋“  ํ”„๋กœํผํ‹ฐ์— ์ ‘๊ทผ์ด ๊ฐ€๋Šฅํ•˜๋‹ค.

์ด๋•Œ malloc() ์œผ๋กœ ์ดˆ๊ธฐํ™”๋œ ๊ตฌ์กฐ์ฒด ๋‚ด๋ถ€ ํ”„๋กœํผํ‹ฐ๋Š” ์ด์ƒํ•œ ๊ฐ’์„ ๊ฐ€์ง„๋‹ค.
๋งŒ์•ฝ 0์œผ๋กœ ์ดˆ๊ธฐํ™”๊ฐ€ ํ•„์š”ํ•œ ๊ฒฝ์šฐ memset์„ ์“ฐ๋„๋ก ํ•˜์ž

typedef struct {
	int test1; // ์ด๋•Œ ๊ตฌ์กฐ์ฒด ํฌ์ธ๊ฐ€ ๊ฐ€๋ฅดํ‚ค๋Š” ์ฃผ์†Œ๋Š” ํ•ด๋‹น ๋ณ€์ˆ˜์ž„
	char test2[100];
} Client;
 
 
// obj ๋ณ€์ˆ˜๋Š” ํ•ด๋‹น malloc ์œผ๋กœ ์ดˆ๊ธฐํ™” ํ•œ ๊ตฌ์กฐ์ฑ„ ์˜ `test1` ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๊ฐ’์ž„
ClientList *test = (ClientList*) obj;
 
// ๋ชจ๋“  ํ”„๋กœํผํ‹ฐ๋ฅผ 0(NULL) ๋กœ ์ดˆ๊ธฐํ™”
memset(test, 0, sizeof(test));
 
//์ด์ œ ์ด๋ ‡๊ฒŒ ์ฐธ์กฐ ๊ฐ€๋Šฅ
test->test2

๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น ํ—ค์ œ ์‹œ ์œ ์˜์‚ฌํ•ญ

  • ๊ตฌ์กฐ์ฒด ๋‚ด๋ถ€ ํ”„๋กœํผํ‹ฐ์˜ ์ฃผ์†Œ๊ฐ’์œผ๋กœ free ํ•˜๋Š” ๊ฒฝ์šฐ

    typedef struct struct_t {
        int a;
        char b;
    } struct_t;

    struct_t์˜ b ๋ณ€์ˆ˜์˜ ์ฃผ์†Œ๊ฐ’์„ ์•Œ๊ณ ์žˆ๋Š” ๊ฒฝ์šฐ free(b) ๋ฅผ ํ˜ธ์ถœํ•œ๋‹ค๋ฉด?
    ๊ฒฐ๋ก ์€ ๊ตฌ์กฐ์ฒด ์ „์ฒด ์˜์—ญ์ด ๋ฉ”๋ชจ๋ฆฌ์—์„œ ํ• ๋‹น ํ•ด์ œ

    free()๋Š” ํ•ด๋‹น ์ฃผ์†Œ์— ๋ฉ”๋ชจ๋ฆฌ ๋ฒ”์œ„๋ฅผ ์ „์ฒด ํƒ์‚ญํ•˜๊ณ  ์‚ญ์ œํ•˜๊ธฐ ๋•Œ๋ฌธ

    ๊ฐ๊ฐ์„ ๋”ฐ๋กœ ๊ด€๋ฆฌํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด char *b ๋กœ ์„ ์–ธํ•˜์—ฌ b ๋ณ€์ˆ˜๋ฅผ ๋”ฐ๋กœ malloc ์œผ๋กœ ์ดˆ๊ธฐํ™” ํ•ด์•ผํ•จ

  • free๋œ ๋ณ€์ˆ˜ ๊ทธ ์ž์ฒด๋Š” NULL๋กœ ๋งŒ๋“ค๋ฉด ์•ˆ๋œ๋‹ค.

    int *a = (int*)malloc(sizeof(int) * 10);
    free(a);
    a = NULL;

    ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์•ˆ๋˜๋Š” ์ด์œ ๋Š” ํ• ๋‹น ํ•ด์ œ ์ดํ›„์—๋Š” ๋‹ค๋ฅธ ๋ฉ”๋ชจ๋ฆฌ ์˜์—ญ์ด
    ํ•ด๋‹น ํฌ์ธํ„ฐ ์ฃผ์†Œ๊ฐ’์„ ์“ธ ์ˆ˜ ๊ฐ€ ์žˆ๋‹ค.

    ์ด๊ฒŒ ๋ญ˜ ์˜๋ฏธ ํ•˜๋ƒ๋ฉด ๋ฉ€ํ‹ฐ์“ฐ๋ ˆ๋”ฉ ํ™˜๊ฒฝ์—์„œ๋Š” free ๋œ ์ดํ›„ ๋‹ค๋ฅธ ์“ฐ๋ ˆ๋“œ์—์„œ malloc ์œผ๋กœ ํ• ๋‹น ๋ฐ›๋Š” ์ƒํ™ฉ์ด ๋ฐœ์ƒ ํ•  ์ˆ˜ ์žˆ๋‹ค. ๊ทธ๋Ÿผ ์ € free ๋œ ์˜์—ญ์„ ํ• ๋‹น ๋ฐ›์„ ์ˆ˜ ๋„ ์žˆ๋‹ค๋Š” ๊ฒƒ์ด๋‹ค.

    ๊ทธ๋ž˜์„œ ํ•ด๋‹น ํฌ์ธํ„ฐ๋ฅผ NULL๋กœ ๋ฐ”๊พผ๋‹ค๋ฉด ๋‹ค๋ฅธ ์“ฐ๋ ˆ๋“œ๊ฐ€ ํ• ๋‹น์ค‘์ธ malloc() ์˜์—ญ์„ ์นจ๋ฒ” ํ•  ๊ฐ€๋Šฅ์„ฑ์ด ์ƒ๊ธด๋‹ค.

    ๊ทธ๋ฆฌ๊ณ  ์—์ดˆ์— ์ €๋Ÿฐ์‹์œผ๋กœ NULL๋กœ ๋ฐ”๊พธ๋Š”๊ฒŒ ์˜๋ฏธ๊ฐ€ ์—†๋Š” ๊ฒŒ ์ง€์—ญ ๋ณ€์ˆ˜ *a ์— ๋Œ€ํ•ด NULL๋กœ ๊ฐ’์„ ๋ฐ”๊พธ๋Š” ๊ฑฐ๋ผ ๋ฒ”์œ„๋ฐ–์— ๊ฐ’์„ ๋ฐ”๊พธ์ง€ ๋ชปํ•œ๋‹ค.

  • ๊ตฌ์กฐ์ฒด ๋‚ด๋ถ€ ๋ณ€์ˆ˜์— NULL ์ ์šฉ์€ ๊ฐ€๋Šฅํ•˜๋‹ค.

    typedef struct {
        char *str;
        int index;  
    } Obj;
     
    Obj *a = (Obj*)malloc(sizeof(Obj));
    a->str = (char*)malloc(sizeof(char) * 100);
    free(a->str);
    a->str = NULL;

    ๊ตฌ์กฐ์ฒด ๋‚ด๋ถ€๋ณ€์ˆ˜๋ฅผ ํž™์˜์—ญ์œผ๋กœ ์ดˆ๊ธฐํ™” ํ•œ ๊ฒฝ์šฐ์—๋Š” NULL ์ฃผ์†Œ๋กœ ๋ฐ”๊พธ๋Š”๊ฒŒ ๊ฐ€๋Šฅํ•˜๋‹ค.

    ํ•ด๋‹น ์ฃผ์†Œ๋ฅผ NULL๋กœ ๋ฐ”๊พธ๋”๋ผ๋„ ์–ด์ฐจํ”ผ ๋ฉ”์ธ ๊ตฌ์กฐ์ฒด ์ž์ฒด๊ฐ€ ์ฃผ์†Œ๊ฐ’์„ ๊ฐ€์ง€๋ฏ€๋กœ free ๋˜์—ˆ๋‹ค ํ•œ๋“ค ํ•ด๋‹น ์˜์—ญ์— ํ• ๋‹น์ด ์ด๋ฃจ์–ด ์งˆ ์ˆ˜ ์—†๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

    ๋˜ํ•œ ๊ตฌ์กฐ์ฒด์˜ ์ฃผ์†Œ๊ฐ’ ์ฐธ์กฐ๋ฅผ ํ†ตํ•ด NULL๋กœ ๋ฐ”๊พธ๊ฒŒ ๋˜๋ฉด ๋ฒ”์œ„ ๋ฐ–์—์„œ๋„ ์ ์šฉ ๊ฐ€๋Šฅํ•˜๋‹ค.

๊ธฐํƒ€์˜์—ญ (ํฌ์ธํ„ฐ ๋ณ€์ˆ˜)

char *buff ์ด๋Ÿฐ์‹์œผ๋กœ ์„ ์–ธ๋œ ํฌ์ธํ„ฐ ๋ณ€์ˆ˜๋Š” ์Šคํƒ/ํž™/๋ฐ์ดํ„ฐ ์˜์—ญ ์ƒ๊ด€์—†์ด ์–ด๋””์„œ๋“  ์“ธ ์ˆ˜ ์žˆ๋‹ค.

๊ทธ๋ž˜์„œ ์œ„์— ์Šคํƒ๋ณ€์ˆ˜์— Undefined Behavior ํ•ญ๋ชฉ์—์„œ ์„ค๋ช…ํ–ˆ๋“ฏ์ด ์Šคํƒ ๋ณ€์ˆ˜๋ฅผ ํฌ์ธํ„ฐ ๋ณ€์ˆ˜๋กœ ํ•œ๋ฒˆ mapping ํ•ด์„œ ๋ฐ˜ํ™˜ํ•˜๋ฉด ์ •์ƒ์ ์œผ๋กœ ๋ฐ˜ํ™˜๋˜๋Š”๊ฒƒ ์ฒ˜๋Ÿผ ๋ณด์ผ ์ˆ˜ ์žˆ๋Š”๊ฒƒ์ด๋‹ค. ใ„ด

๋น„ํŠธ ๋‹จ์œ„ ๊ฐ’ ํŒ๊ฒฐ

ํŒ๋ณ„ํ•˜๊ณ  ์‹ถ์€ ๋น„ํŠธ๋ฅผ 1๋กœ ๋‘๊ณ  ๋‚˜๋จธ์ง€๋Š” 0์œผ๋กœ ๋‘๋Š” ๋น„ํŠธ ๋งˆ์Šคํฌ ์ƒ์„ฑํ•ด์„œ & ์—ฐ์‚ฐ

int main(int argc, char const *argv[]) {
    char a = 12;
    char b = 0b0000100;
 
    printf("%d\n", a & b);
	// 0, 1๋กœ ์ถœ๋ ฅ ๋˜๊ฒŒ ํ•˜๊ณ ์‹ถ์œผ๋ฉด ๋น„ํŠธ์‰ฌํ”„ํŠธ ์‚ฌ์šฉ 
	printf("%d\n", (a & b) >> 2);
    return 0;
}

๊ฐ€๋ณ€ ์ธ์ž

#include <stdarg.h>
 
void varargs(int count, ...) {
    va_list arg;
    // ๊ฐ€๋ณ€์ธ์ž ์‚ฌ์šฉ
    va_start(arg, count);
    for (int i = 0; i < count; i++) {
	    // va_arg์— 2๋ฒˆ์งธ ์ธ์ž๋Š” ๊ฐ€๋ณ€์ธ์ž๋กœ ๋ฐ›์„ ๋ณ€์ˆ˜ ํƒ€์ž…์— ๋”ฐ๋ผ ๋ณ€๊ฒฝ
        printf("%s\n", va_arg(arg, char *));
    }
 
	// ๊ฐ€๋ณ€์ธ์ž ์ข…๋ฃŒ
    va_end(arg);
}
 
void main() {
	//2 ๋ผ๋Š” ์ˆซ์ž๋Š” ๋’ค์— ๊ฐ€๋ณ€์ธ์ž ๊ฐœ์ˆ˜๋ฅผ ๋œปํ•จ
    varargs(2, "์–ธ์  ๊ฐ€", "๊ทธ๊ฐ€ ๋„ˆ๋ฅผ");
}

๊ฐ€๋ณ€์ธ์ž๋Š” ... ์œผ๋กœ ์„ ์–ธํ•˜๊ณ  va_list ๋ผ๋Š”๊ฑธ ํ†ตํ•ด์„œ ์ฒ˜๋ฆฌํ•˜๋ฉด ๋˜๋Š”๋ฐ

int count์ด๊ฒŒ ์™œ ํ•„์š”ํ•˜๋ƒ C์–ธ์–ด์—์„œ๋Š” ๊ฐ€๋ณ€ ์ธ์ž ๊ฐœ์ˆ˜๋ฅผ ์ž๋™์œผ๋กœ ํŒŒ์•…ํ•  ์ˆ˜ ์—†๋‹ค.
๊ทธ๋‹ˆ๊นŒ ์‚ฌ์šฉ์ž๊ฐ€ ์ง์ ‘ ๊ฐ€๋ณ€์ธ์ž ๊ฐœ์ˆ˜๋ฅผ ๊ธฐ์ž…ํ•ด์„œ ์ฒ˜๋ฆฌ ํ•ด์•ผํ•œ๋‹ค.

๊ฐ€๋ณ€ ์ธ์ž๋ฅผ ์ฒ˜๋ฆฌ๋Š” va_start-va_end ๋ธ”๋ก ๋‚ด๋ถ€์— ์ฒ˜๋ฆฌ ํ•ด์•ผํ•œ๋‹ค
va_start() ๋ฅผ ํ†ตํ•ด์„œ ์‚ฌ์šฉ์„ ์–ธ์„ ํ•˜๊ณ 
๋‹ค ์ผ์œผ๋ฉด (๋ชจ๋“  ๊ฐ€๋ณ€์ธ์ž๋ฅผ ๋‹ค ๋ถˆ๋Ÿฌ์™”๋‹ค๋ฉด) va_end()๋กœ ์ข…๋ฃŒํ•ด์•ผํ•œ๋‹ค.

์ž‘๋™ ๋ฐฉ์‹์ด va_start๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ์ž๋™์œผ๋กœ ๊ฐ€๋ณ€์ธ์ž ์ค‘ ์ฒซ๋ฒˆ์งธ ๊ฐ€๋ณ€ ์ธ์ž์— ์ฃผ์†Œ๋ฅผ ๊ฐ€๋ฅดํ‚ค๋„๋ก ์…‹ํŒ… ๋˜๊ณ  va_arg์„ ํ†ตํ•ด char * ๋งŒํผ ์”ฉ ํฌ์ธํ„ฐ๋ฅผ ์ด๋™ํ•˜์—ฌ ๋‹ค์Œ ์ธ์ž๋ฅผ ๋ถˆ๋Ÿฌ์˜ค๋„๋ก ํ•˜๊ณ ์žˆ๋‹ค.
๋‹ค ์‚ฌ์šฉํ•˜๋ฉด va_end๋ฅผ ํ˜ธ์ถœํ•˜์—ฌ ํฌ์ธํ„ฐ์— ์œ„์น˜๋ฅผ ๋ฆฌ์…‹์‹œํ‚ค๊ฒŒ ๋œ๋‹ค.

์—ฌ๊ธฐ์„œ ์•Œ ์ˆ˜ ์žˆ๋Š” ์‚ฌ์‹ค์ด ํ•œ๋ฒˆ์— va_start-va_end ๋ธ”๋ก์—์„œ ๋˜‘๊ฐ™์€ ๊ฐ€๋ณ€ ์ธ์ž๋ฅผ ์—ฌ๋Ÿฌ๋ฒˆ ๋ถˆ๋Ÿฌ ์˜ฌ ์ˆ˜ ์—†๋‹ค๋Š” ๊ฒƒ์ด๋ฉฐ, ๊ทธ๋ ‡๊ฒŒ ํ•˜๊ณ  ์‹ถ์„๋•Œ๋Š” ๋‹ค๋ฅธ va_start-va_end ๋ธ”๋ก์„ ๋งŒ๋“ค์–ด์„œ ํ•ด์•ผํ•œ๋‹ค๋Š” ๊ฒƒ์ด๋‹ค.

์„œ์‹๋ฌธ์ž ์ฒ˜๋ฆฌํ•˜๋Š” ๋ฒ•

์œ„ ๋‹จ์ˆœํžˆ ์ธ์ž๋ฅผ ์ „๋‹ฌํ•˜๋Š” ๊ฒƒ ์™ธ์— C์–ธ์–ด์— ๊ฐ€๋ณ€์ธ์ž๋Š” printf ๋“ฑ์—์„œ ์‚ฌ์šฉํ•˜๋Š” ์„œ์‹๋ฌธ์ž์— ์ฒ˜๋ฆฌ๋ฅผํ•  ์ˆ˜ ์žˆ๋‹ค.

void varargs(char *format, ...) {
    va_list arg;           // ๊ฐ€๋ณ€์ธ์ž ๋ฆฌ์ŠคํŠธ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ
    va_start(arg, format);  // ๊ฐ€๋ณ€์ธ์ž ๋ฆฌ์ŠคํŠธ ํฌ์ธํ„ฐ๋ฅผ ์ฒซ ์ฃผ์†Œ๋กœ ์ดˆ๊ธฐํ™”
 
	// ์„œ์‹ ๋ฌธ์ž๋กœ ์ถœ๋ฃํ•˜๊ธฐ
    vprintf(format, arg);
 
    va_end(arg);
}
 
void main() {
    varargs("๊ทธ๋ƒฅ ๊ฐ’: %d\n", 10);
}
// ์ถœ๋ ฅ: ๊ทธ๋ƒฅ ๊ฐ’: 10

์ผ๋ฐ˜ ๊ฐ€๋ณ€์ธ์ž ์ฒ˜๋ฆฌํ•˜๋Š” ๊ฒƒ๊ณผ ๋™์ผํ•˜๊ฒŒ va_start-va_end ๋ธ”๋ก ๋‚ด๋ถ€์—์„œ ์ฒ˜๋ฆฌํ•ด์•ผ ํ•˜๋ฉฐ,
๊ฐ€๋ณ€์ธ์ž๋ฅผ ์‹๋ณ„ํ•  ๊ณ ์ •์ธ์ž๋ฅผ char *์„ ์–ธ ํ•˜๊ฒŒ ๋˜๊ณ  ํ•ด๋‹น ์ธ์ž ๋ถ€๋ถ„์— ์„œ์‹ ๋ฌธ์ž์—ด์„ ์ง€์ •ํ•˜๊ณ , ๋‚˜๋จธ์ง€ ์ธ์ž๋Š” ๋ณ€์ˆ˜๋กœ ์ฑ„์šฐ๊ฒŒ ๋œ๋‹ค.

์•„๋ž˜ ์ฒ˜๋Ÿผ ์‚ฌ์šฉ ํ•  ๊ฒฝ์šฐ len๋ณ€์ˆ˜๋Š” ์„œ์‹ ๋ฌธ์ž๋ฅผ ํ†ตํ•ด ๋งŒ๋“ค์–ด์ง€๋Š” ๋ฌธ์ž์—ด์— ๊ธธ์ด๋ฅผ ๋‚˜ํƒ€๋‚ธ๋‹ค
๊ทธ๋Ÿผ ๊ทธ ๋ณ€์ˆ˜๋กœ ๊ฐ€๋ณ€ ๋ฐฐ์—ด์„ ๋งŒ๋“ค์–ด์„œ ํ•ด๋‹น ๋ฐฐ์—ด์— ์™„์„ฑ๋œ ๋ฌธ์ž์—ด์„ ์ €์žฅํ•˜๋Š” ์šฉ๋„๋กœ ์“ธ ์ˆ˜ ์žˆ๋‹ค.

va_start(args, _Format);
int len = vsnprintf(NULL, 0, _Format, args);
va_end(args);
 
char buf[len + 1];
 
va_start(args, _Format);
vsnprintf(buf, len + 1, _Format, args);
va_end(args);

vprintf, vsnprintf ๊ธฐ์กด ์ž…์ถœ๋ ฅ ํ•จ์ˆ˜์™€, ํŒŒ์ผ ํ•จ์ˆ˜์— ์„œ์‹ ๋ฌธ์ž ๋ž˜ํ•‘ ํ•จ์ˆ˜๊ฐ€ ์—ฌ๋Ÿฟ ์กด์žฌ ํ•˜๋Š”๋ฐ
์•„๋ž˜ ํ•จ์ˆ˜ ์ •๋ฆฌ ํŒŒํŠธ์—์„œ ์ •๋ฆฌํ•ด ๋‘์—ˆ๋‹ค

void ํฌ์ธํ„ฐ

C์–ธ์–ด์— void ํฌ์ธํ„ฐ๋Š” ๋ณดํ†ต callback ๊ตฌํ˜„์ด๋‚˜ ๊ธฐํƒ€ ํด๋กœ์ ธ ๊ธฐ๋Šฅ ๊ฐ™์€ ์—ญํ• ์„ ์ˆ˜ํ–‰ํ•œ๋‹ค.
์—ฌ๊ธฐ์„œ ์•Œ ์ˆ˜ ์žˆ๋Š” ์‚ฌ์‹ค์€ ํ•จ์ˆ˜๋ฅผ ()๋กœ ํ˜ธ์ถœํ•˜์ง€ ์•Š์œผ๋ฉด void * ์ž๋ฃŒํ˜•์œผ๋กœ ๊ฐ„์ฃผ๋œ๋‹ค.

// `test_cb`๋Š” ํƒ€์ž… ์ด๋ฆ„
// `int num`์€ callback ํ•จ์ˆ˜์— ๊ตฌํ˜„๋  ์ธ์ž
typedef void (*test_cb)(int num);
 
void test(test_cb cb) {
    cb(10);
}
 
void my_cb(int num) {
    printf("test_cb: %d\n", num);
}
 
void main() {
    test(my_cb);
}

ํ•จ์ˆ˜๋‚˜, ๊ธฐํƒ€ ํƒ€์ž…์ด ๋ช…ํ™•ํ•˜์ง€ ์•Š๋Š” ์ž๋ฃŒํ˜•์„ ๋ญ‰๋šฑ๊ทธ๋ ค์„œ void *๋กœ ์ง€์ •ํ•œ ๋‹ค์Œ ์‚ฌ์šฉ์ž๊ฐ€ ์ง์ ‘ ํ˜• ๋ณ€ํ™˜ ํ•ด์„œ ์“ฐ๋„๋ก ํ•˜๋Š” ๊ฒฝ์šฐ๋„ ์žˆ๋‹ค.

typedef void (*test_cb)(void *data);
 
void test(void *data, test_cb cb) { 
    cb(data);
}
 
void my_cb(void *data) {
    // ์›ํ•˜๋Š” ์ž๋ฃŒํ˜•์œผ๋กœ ํ˜•๋ณ€ํ™˜
    char *str = (char *)data;
    printf("%s\n", str);
}
 
void main() {
    char *str = "Hello World!";
    test(str, my_cb);
}

์‹คํ–‰ ์ธ์ž ์ฒ˜๋ฆฌ๋ฒ•

์ฐธ๊ณ ์ž๋ฃŒ

์‹คํ–‰ ์ธ์ž ์ฒ˜๋ฆฌ๋Š” getopt_long ํ•จ์ˆ˜๋กœ ์ฒ˜๋ฆฌ ํ•  ์ˆ˜ ์žˆ๋‹ค.
์œ„ ์ฐธ๊ณ ์ž๋ฃŒ์—๋Š” getopt๋กœ ์ฒ˜๋ฆฌํ•˜๋Š”๋ฐ ๊ทธ๋Ÿฌ๋ฉด ๊ธด ์ธ์ž๋ฅผ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์—†๊ธฐ์— getopt_long์œผ๋กœ ํ•œ๋‹ค.

  • ์˜ต์…˜ ๋ชฉ๋ก ๋งŒ๋“ค๊ธฐ

    struct option run_args[] = {{"port", required_argument, 0, 'p'},
    ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  {"dns", required_argument, 0, 0},
    ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  {"timeout", no_argument, 0, 't'},
    ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  {"help", no_argument, 0, 'h'},
    ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  {"nolog", no_argument, 0, 0},
    ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  {"logfile", required_argument, 0, 'l'},
    ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  ย  {0, 0, 0, 0}};
    • 0: ๊ธด ์ธ์ž,
    • 1: required_argument: ์‹คํ–‰์ธ์ž์— ๊ฐ’์ด ๋“ค์–ด๊ฐ
    • 2: ๊ทธ๋ƒฅ 0 ๊ณ ์ •
    • 3: ์ถ•์•ฝ ์ธ์ž, ์—†์œผ๋ฉด 0์œผ๋กœ
  • ์˜ต์…˜ ์ธ์ž ํŒŒ์‹ฑ

            while ((opt = getopt_long(argc, argv, "p:ht:l:", run_args, &option_index)) != -1) {
                switch (opt) {
    	            // ์ถ•์•ฝ์ธ์ž๊ฐ€ ์—†๋Š”๊ฒฝ์šฐ
                    case 0:
                        if (strcmp(run_args[option_index].name, "nolog") == 0) {
                            SERVER_CONFIG.noLog = 1;
                        }
                        break;
                    case 'p':
                        if (atoi(optarg) < 1 || atoi(optarg) > 65535) {
                            put_log(LOG_ERROR, "์ž˜๋ชป๋œ ํฌํŠธ๋ฒˆํ˜ธ");
                            return 1;
                        }
                        SERVER_CONFIG.port = atoi(optarg);
                        break;
                    // ์ž˜๋ชป ์ž…๋ ฅ
                    default:
                        put_log(LOG_INFO, "'%s --help' ๋กœ ์„ค๋ช…์„ ํ™•์ธํ•ด ๋ณด์„ธ์š”.", argv[0]);
                        return 0;
                }
            }

ํ•จ์ˆ˜ ์ •๋ฆฌ

๋ฌธ์ž์—ด ํ•จ์ˆ˜

  • char * strdup(const char *_String): ๋ฌธ์ž์—ด์„ ํž™ ์˜์—ญ์œผ๋กœ ๋ณต์‚ฌ

    • ํŠน์ • ๋ฌธ์ž์—ด์„ ํ•จ์ˆ˜ ์™ธ๋ถ€์—๋„ ์จ์•ผ๋˜์„œ ํž™ ์˜์—ญ์œผ๋กœ ๋ณต์‚ฌ ํ•ด์•ผ ๋ ๋•Œ
      malloc + memcpy ์กฐํ•ฉ ๋Œ€์‹  ์“ฐ๋Š” ๋ฐฉ๋ฒ•

      <์ฃผ์˜ํ• ์ >
      ๋ฌธ์ž์—ด์— ๋Œ€ํ•œ ๋ณต์‚ฌ๋Š” \0 ์ฆ‰ ๋ฐ”์ด๋„ˆ๋ฆฌ๋กœ 0x00์„ ๋งŒ๋‚˜๋Š” ์ง€์ ๊นŒ์ง€๋งŒ ๋ณต์‚ฌ๊ฐ€ ๋จ
      ๊ทธ๋ž˜์„œ ๋‚ด๊ฐ€ ๋ณต์‚ฌ ํ•˜๋ ค๋Š” ๋ฐ์ดํ„ฐ๊ฐ€ ์ง„์งœ ๋ฌธ์ž์—ด์ธ์ง€, ์•„๋‹ˆ๋ฉด ๋ฐ”์ด๋„ˆ๋ฆฌ๋ฅผ ํฌํ•จํ•œ ํ˜•ํ…Œ์˜ ๋ฌธ์ž์—ด์ธ์ง€ ๋ฅผ์ž˜ ์•Œ์•„์•ผ ํ•จ

      char str[] = "์•ˆ๋…•ํ•˜์„ธ์š”";
      char *p = strdup(str);
  • char * strncpy(char *_Destination, const char *_Source, size_t _Count): ๋ฌธ์ž์—ด ๋ณต์‚ฌ

    • _Source ๋ฌธ์ž์—ด์„ _Destination ์œผ๋กœ ๋ณต์‚ฌ
      ์œ„ strdup ๋งˆ๋ƒฅ ๋ฉ”๋ชจ๋ฆฌ ์˜์—ญ์ด ๋‹ฌ๋ผ์ง€์ง„ ์•Š๊ณ  ๊ทธ๋ƒฅ ๋‹จ์ˆœ ์˜์—ญ ๋ณต์‚ฌ

      _Count: ๋ณต์‚ฌํ•  ๊ธธ์ด

      ๋ฐ˜ํ™˜: _Destination ์ฃผ์†Œ๊ฐ’ (๋ฌด์‹œ ํ•ด๋„ ๋ ๋“ฏ)

      <์ฃผ์˜ํ• ์ >
      ๋ฌธ์ž์—ด์— ๋Œ€ํ•œ ๋ณต์‚ฌ๋Š” \0 ์ฆ‰ ๋ฐ”์ด๋„ˆ๋ฆฌ๋กœ 0x00์„ ๋งŒ๋‚˜๋Š” ์ง€์ ๊นŒ์ง€๋งŒ ๋ณต์‚ฌ๊ฐ€ ๋จ
      ๊ทธ๋ž˜์„œ ๋‚ด๊ฐ€ ๋ณต์‚ฌ ํ•˜๋ ค๋Š” ๋ฐ์ดํ„ฐ๊ฐ€ ์ง„์งœ ๋ฌธ์ž์—ด์ธ์ง€, ์•„๋‹ˆ๋ฉด ๋ฐ”์ด๋„ˆ๋ฆฌ๋ฅผ ํฌํ•จํ•œ ํ˜•ํ…Œ์˜ ๋ฌธ์ž์—ด์ธ์ง€ ๋ฅผ์ž˜ ์•Œ์•„์•ผ ํ•จ

      ๋งŒ์•ฝ ๋ฐ”์ด๋„ˆ๋ฆฌ ๋ผ๋ฉด memmove()๋ฅผ ์“ฐ๋„๋ก ํ•˜์ž.

      char str[] = "์•ˆ๋…•ํ•˜์„ธ์š”";
      char *p = malloc(100 * sizeof(char));
      strcpy(p, str);
  • char * strchr(const char *_Str, int _Val): ๋ฌธ์ž ์กด์žฌ์—ฌ๋ถ€ & ๊ตฌ๋ถ„์ž

    • _Str ๋ฌธ์ž์—ด์— _Val ๋ฌธ์ž๊ฐ€ ๋“ฑ์žฅํ•˜๋Š” ์œ„์น˜์— ์ฃผ์†Œ๊ฐ’์„ ๋ฐ˜ํ™˜

      ๋งŒ์•ฝ _Val ๋ฌธ์ž์—ด์ด ์กด์žฌํ•˜์ง€ ์•Š์œผ๋ฉด NULL์„ ๋ฐ˜ํ™˜

      ์ด๋Ÿฐ ์„ฑ์งˆ์„ ์‚ฌ์šฉํ•ด์„œ ๋ฌธ์ž ์กด์žฌ ์—ฌ๋ถ€ ๋ฟ ์•„๋‹ˆ๋ผ ๊ตฌ๋ถ„์ž๋กœ ์‚ฌ์šฉํ•ด ๋ฌธ์ž๋ฅผ ๋‚˜๋ˆ„๋Š” ์—ญํ• ๋„
      ๊ฐ€๋Šฅ

      ๋ฌธ์ž์—ด ์กด์žฌ ์—ฌ๋ถ€๋‚˜ ๋ฌธ์ž์—ด๋กœ ๊ตฌ๋ถ„์ž๋ฅผ ํ•˜๊ณ ์‹ถ๋‹ค๋ฉด strtokํ•จ์ˆ˜๋ฅผ ์“ฐ๋„๋ก ํ•˜์ž

      ๋งŒ์•ฝ _Val ๋ฌธ์ž๊ฐ€ ์—ฌ๋ ค ๊ฐœ ์กด์žฌํ•˜๋”๋ผ๋„ ๊ฐ€์žฅ ์ฒซ๋ฒˆ์งธ ๋“ฑ์žฅํ•œ ๋ฌธ์ž ์ฃผ์†Œ๋ฅผ ๋ฐ˜ํ™˜

      char str[] = "์•ˆ๋…•:ํ•˜์„ธ์š”";
      strchr(str, ':');
      char* token = strchr(str, ':');
      // : ๋ฌธ์ž๋ฅผ NULL๋กœ ๋ฐ”๊ฟ”์„œ ๋ฌธ์ž์—ด์„ ๋‚˜๋ˆ„๋Š” ๋ฐฉ๋ฒ•
      *token = '\0';
      printf("%s\n", str); // ์•ˆ๋…•
      printf("%s\n", token + 1); //ํ•˜์„ธ์š”
  • int strcmp(const char *_Str1, const char *_Str2): ๋ฌธ์ž์—ด ๋™์ผ ๋น„๊ต

    • ๋ฐ˜ํ™˜๊ฐ’: 0์ด๋ฉด ๋™์ผํ•œ๊ฑฐ 1์ด๋ฉด ๋‹ค๋ฅธ๊ฑฐ

      char str[] = "์•ˆ๋…•ํ•˜์„ธ์š”";
      int res = strcmp(str, "์•ˆ๋…•ํ•˜์„ธ์š”");
      printf("res: %d\n", res);
  • int atoi(const char *_String): ๋ฌธ์ž์—ด โ†’ ์ˆซ์ž

๋ฒ„ํผ ํ• ๋‹น ํ•จ์ˆ˜ & ์„œ์‹ ๋ฌธ์ž ์‚ฌ์šฉํ•จ์ˆ˜

์ฐธ๊ณ ๋กœ %d, %s ๊ฐ™์ด prtinf ํ•จ์ˆ˜๊ฐ™์€๋ฐ์„œ ์‚ฌ์šฉํ•˜๋Š” ํŠน์ˆ˜ ๊ธฐํ˜ธ๋ฅผ ์„œ์‹๋ฌธ์ž๋ผ ํ•จ

  • int snprintf(char *const _Buffer, const size_t _BufferCount, const char *const _Format, ...): ๋ฌธ์ž์—ด์— ๋ณ€์ˆ˜ ํฌํ•จ

    • printf ๋งˆ๋ƒฅ ์„œ์‹๋ฌธ์ž ์จ์„œ _Buffer์— ์ €์žฅ

      ์ฆ‰ ๋ฌธ์ž์—ด _Buffer์— ๋ณ€์ˆ˜๋ฅผ ํฌํ•จํ•˜์—ฌ ์ €์žฅ

      _BufferCount: ๋ฌธ์ž์—ด์— ์ตœ์ข… ํฌ๊ธฐ ์ง€์ •

      ์ฐธ๊ณ ๋กœ sprintf๊ฐ€ ํ•ด๋‹น ํ•จ์ˆ˜ ์›ํ˜•์ธ๋ฐ ์•ˆ์ „ํ•˜์ง€ ์•Š์•„์„œ ์ด๊ฑธ๋กœ ํ•„๊ธฐํ•จ

      char buf[500];
      int i = 10;
      sprintf(buf, 500, "Hello: %s", i);
  • int sscanf(const char *const _Buffer, const char *const _Format, ...): ๋ฌธ์ž์—ด ํƒ€์ž… ๋ถ„๋ฆฌ

    • _Buffer์— ์ด์žˆ๋Š” ๋ฌธ์ž์—ด์„ ํ˜•์‹ ์ง€์ •์ž์— ๋งž๋Š” ํƒ€์ž…์œผ๋กœ ๋ณ€ํ™˜ ํ•ด์„œ ๊ฐ๊ฐ์— ์ธ์ž์— ์ „๋‹ฌํ•ด์คŒ

      ์ฆ‰ ์œ„ sprintf๋Š” ํ˜•์‹๋ฌธ์žโ†’๋ฒ„ํผ ์ธ๋ฐ sscanf๋Š” ๋ฒ„ํผโ†’ ํ˜•์‹ ๋ฌธ์ž์ž„

      ๊ทธ๋ž˜์„œ ํƒ€์ž… ๋ณ€ํ™˜ ํ•  ๋•Œ ์“ฐ๊ธฐ ์ข‹์Œ

      char origin[] = "์•ˆ๋…•์นœ๊ตฌ๋“ค 1";
       
      char buf[500];
      int i = 10;
       
      sscanf(origin, "%s %d", buf, &i);
      printf("%s %d\n", buf, i);

ํŒŒ์ผ ํ•จ์ˆ˜ (๋ฐ”์ด๋„ˆ๋ฆฌ ๋‹ค๋ฃจ๊ธฐ)

์ฐธ๊ณ ๋กœ ํ‘œ์ค€, ์ž…์ถœ๋ ฅ๋„ ์‚ฌ์‹ค ํŒŒ์ผ์ด๋‹ค. ๊ทธ๋ž˜์„œ File *file์— ๊ฐ๊ฐ stdout, stdin, stderr ์ƒ์ˆ˜๋กœ ์„ค์ •ํ•˜๋ฉด ํ‘œ์ค€ ์ž…์ถœ๋ ฅ ์ฒ˜๋ฆฌ๋„ ๊ฐ€๋Šฅํ•˜๋‹ค.

๋Œ€๋ถ€๋ถ„์— ํ•จ์ˆ˜๊ฐ€ ์„œ์‹ ๋ฌธ์ž ํ•จ์ˆ˜์—์„œ ์ƒ์†๋˜์žˆ๋Š”๊ฑฐ๋ผ f*๋กœ ์‹œ์ž‘ํ•˜๊ณ  file ์ŠคํŠธ๋ฆผ์„ ๋‹ค๋ฃฌ๋‹ค๋Š” ์ฐจ์ด ์ •๋„

fputs, fgets๋„ ํŒŒ์ผ ํ•จ์ˆ˜๊ธด ํ•œ๋ฐ ํ…์ŠคํŠธ ๋ฐ์ดํ„ฐ๋งŒ ์ทจ๊ธ‰ ๊ฐ€๋Šฅํ•˜๊ณ  ํŒŒ์ผ ์ชฝ ๋ณด๋‹ค ํ‘œ์ค€์ž… ์ถœ๋ ฅ์— ์œ ์šฉํ•˜์—ฌ ์—ฌ๊ธฐ์— ์„œ์ˆ ํ•˜์ง„ ์•Š์Œ

  • FILE * fopen(const char *_FileName, const char *_Mode): ํŒŒ์ผ ์—ด๊ธฐ

    • _Mode ๊ฐ™์€ ๊ฒฝ์šฐ ์•Œ์•„์„œ ์ฐพ์•„๋ณผ ๊ฒƒ (๋ณดํ†ต ๋‹ค๋ฅธ์–ธ์–ด๋ž‘ ๋น„์Šทํ•จ)
      ๋งŒ์•ฝ ํŒŒ์ผ์„ ์—ด ์ˆ˜ ์—†๋Š” ๊ฒฝ์šฐ ๋ฐ˜ํ™˜ ๊ฐ’์€ NULL
  • int fflush(FILE *_Stream): ๋ฒ„ํผ ๋น„์šฐ๊ธฐ

    • fclose ํ˜ธ์ถœํ•˜๊ธฐ์ „ ๋ฐ˜๋“œ์‹œ ํ˜ธ์ถœํ•˜๊ณ  ๊ฐ€์ž
  • int fclose(FILE *_Stream): ์ŠคํŠธ๋ฆผ ๋‹ซ๊ธฐ

    • ํŒŒ์ผ ์ž‘์—… ์ „์ฒด ๋‹ค ๋๋‚˜๋ฉด ํ˜ธ์ถœ
  • size_t fread(void *_Buffer, size_t _ElementSize, size_t _ElementCount, FILE *_Stream): ํŒŒ์ผ ์ฝ์–ด์„œ ๋ฒ„ํผ์— ์ €์žฅ

    • _Stream ํŒŒ์ผ์—์„œ ์ฝ์–ด _Buffer์— ์ €์žฅ

      _ElementSize: ํŒŒ์ผ์„ ์ฝ๋Š” ๊ธฐ๋ณธ ๋ฐ”์ดํŠธ ๋‹จ์œ„ ์ธ๋ฐ, ๋ญ”๊ฐ€ ํŠน์ˆ˜ํ•œ ๋ชฉ์ ์ด ์—†์ง€ ์•Š๋Š” ์ด์ƒ 1๋กœ ๊ณ ์ •, ์ฆ‰ 1๋ฐ”์ดํŠธ ๋‹จ์œ„๋กœ ์ฝ๊ฒ ๋‹ค๋Š” ๊ฑฐ

      _ElementCount: ์ฝ์„ ํฌ๊ธฐ, ์‚ฌ์‹ค์ƒ _Buffer์— ํฌ๊ธฐ์™€ ๋™์ผํ•˜๊ฒŒ ๊ฐ€์ ธ๊ฐ€์•ผ ํ•จ

      ๋ฐ˜ํ™˜๊ฐ’: ์ •์ƒ์ด๋ฉด ์ฝ์€ ๋ฐ”์ดํŠธ ์ˆ˜, ์˜ค๋ฅ˜์ด๊ฑฐ๋‚˜, ๋‹ค ์ฝ์œผ๋ฉด 0
      ๋งŒ์•ฝ ํ…์ŠคํŠธ๋ฅผ ๋‹ค๋ฃจ๋Š”๊ฑฐ๋ผ๋ฉด _Buffer[์ฝ์€ ๋ฐ”์ดํŠธ ์ˆ˜+1]=\0์„ ์ถ”๊ฐ€ํ•˜์ž.
      ํƒœ์ƒ์ด ๋ฐ”์ด๋„ˆ๋ฆฌ๋ฅผ ๋‹ค๋ฃจ๋Š”๊ฑฐ๋ผ ์ž๋™์œผ๋กœ ํ…์ŠคํŠธ ๋์ฒ˜๋ฆฌ๋ฅผ ์•ˆํ•ด์ค€๋‹ค.

  • size_t fwrite(const void *_Buffer, size_t _ElementSize, size_t _ElementCount, FILE *_Stream): ๋ฒ„ํผ๋กœ ํŒŒ์ผ ์“ฐ๊ธฐ & ๋ฐ”์ด๋„ˆ๋ฆฌ ์ถœ๋ ฅ

    • _Buffer์—์žˆ๋Š” ๋ฐ์ดํ„ฐ๋ฅผ _StreamํŒŒ์ผ์— ์“ฐ๊ธฐ

      _ElementSizeํŒŒ์ผ์— ์“ฐ๋Š” ๊ธฐ๋ณธ ๋ฐ”์ดํŠธ ๋‹จ์œ„ ์ธ๋ฐ, ๋ญ”๊ฐ€ ํŠน์ˆ˜ํ•œ ๋ชฉ์ ์ด ์—†์ง€ ์•Š๋Š” ์ด์ƒ 1๋กœ ๊ณ ์ •, ์ฆ‰ 1๋ฐ”์ดํŠธ ๋‹จ์œ„๋กœ ์“ฐ๊ฒ ๋‹ค๋Š” ๊ฑฐ

      _ElementCount๋Š” _Buffer์—์„œ ์‹ค์ œ ์“ฐ๊ธฐ ๊ธธ์ด

      ๋ฐ˜ํ™˜๊ฐ’: ์ •์ƒ์ด๋ฉด ์“ด ๋ฐ”์ดํŠธ ์ˆ˜, ์˜ค๋ฅ˜๋ฉด 0

      <์ฐธ๊ณ >
      _Stream์„ stdout์œผ๋กœ ๋‘”๋‹ค๋ฉด printf์—์„œ๋Š” ๋ฌด์กฐ๊ฑด ๋ฌธ์ž์—ด๋กœ ์ทจ๊ธ‰๋˜์–ด \0 ๋ฌธ์ž์—ด์„ ์ทจ๊ธ‰ํ•˜์ง€ ๋ชปํ•˜๋Š”๋ฐ fwrite๋Š” ๋ฐ”์ด๋„ˆ๋ฆฌ๋ฅผ ๋‹ค๋ฃจ๋Š”๊ฑฐ๋ผ ์ „์ฒด ์ถœ๋ ฅ์ด ๋‚˜์˜ด

      ๊ทธ๋ž˜์„œ ๋ฐ”์ด๋„ˆ๋ฆฌ ์ถœ๋ ฅํ•  ๋•Œ ์‚ฌ์šฉํ•˜๊ธฐ๋„ ํ•จ

  • int fprintf(FILE *const _Stream, const char *const _Format, ...): ์„œ์‹ ๋ฌธ์ž ์‚ฌ์šฉํ•ด์„œ ํŒŒ์ผ์— ์“ฐ๊ธฐ

    • _Stream ํŒŒ์ผ์— ์„œ์‹ ๋ฌธ์ž๋ฅผ ์‚ฌ์šฉํ•ด์„œ ํŒŒ์ผ์— ์“ฐ๊ธฐ
      stdout, stderr๋กœ ์„ค์ • ํ•˜๋ฉด ํ‘œ์ค€ ์ถœ๋ ฅ์œผ๋กœ๋„ ์‚ฌ์šฉ ๊ฐ€๋Šฅ

      fprintf(fp, "์•ˆ๋…• %d\n", num);
  • int fscanf(FILE *const _Stream, const char *const _Format, ...): ํŒŒ์ผ์„ ์ฝ์–ด ๊ฐ๊ฐ ํƒ€์ž…์œผ๋กœ ๋ถ„๋ฆฌ

    • ๊ธฐ๋Šฅ์€ sscanf ๋ž‘ ๋˜‘๊ฐ™์Œ

      const _Stream ํŒŒ์ผ์„ ์ฝ์–ด ๋ฌธ์ž์—ด์„ ํ˜•์‹ ์ง€์ •์ž์— ๋งž๋Š” ํƒ€์ž…์œผ๋กœ ๋ณ€ํ™˜ ํ•ด์„œ ๊ฐ๊ฐ์— ์ธ์ž์— ์ „๋‹ฌํ•ด์คŒ

      ์•„๋ž˜ ์˜ˆ์ œ๋กœ ์„ค๋ช…ํ•˜๋ฉด fp ์—์„œ ์ฝ์–ด์„œ buf, i ๋ณ€์ˆ˜ ๊ฐ๊ฐ ํƒ€์ž…์— ๋งž๊ฒŒ ๋ณ€ํ™˜ํ•ด์„œ ์ „๋‹ฌ

      char buf[500];
      int i = 10;
      sprintf(fp, "%s %d", buf,  i);

์ „์ฒด์ ์ธ ํŒŒ์ผ ์ž…์ถœ๋ ฅ ๋กœ์ง

FILE *fp = fopen("test.txt", "r");
if (fp == NULL) {
	printf("File not found\n");
	return 1;
}
 
char line[256] = {0};
int nread = 0;
while ((nread = fread(line, 1, 256, fp))) {
	line[nread+1] = '\0';
	printf("%s", line);
}
 
fflush(fp);
fclose(fp);

๋งŒ์•ฝ ํ•˜๋‚˜์˜ ํŠน์ • ํŒŒ์ผ์„ ์—ฌ๋Ÿฌ๋ฒˆ ์ฝ๊ธฐ/์“ฐ๊ธฐ๋ฅผ ํ•˜๋ ค๊ณ  ํ•œ๋‹ค๋ฉด
fopen() ์œผ๋กœ ์–ป์€ ํŒŒ์ผ ํฌ์ธํ„ฐ๋ฅผ ์žฌ์‚ฌ์šฉ ํ•˜์ž.

ํŒŒ์ผ ์ž…์ถœ๋ ฅ์ด ํ•„์š” ํ• ๋•Œ ๋งˆ๋‹ค fopen-fclose๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ๋ฏธ์นœ๋“ฏํ•œ ์˜ค๋ฒ„ํ—ค๋“œ๊ฐ€ ๋ฐœ์ƒํ•œ๋‹ค.
๊ทธ๋Ÿฌ๋‹ˆ ์™„๋ฒฝํžˆ ์“ธ์ผ์ด ์—†์„๋•Œ๋งŒ fclose๋ฅผ ํ˜ธ์ถœํ•˜๊ณ  ๊ทธ๋Ÿฌ์ง€ ์•Š์œผ๋ฉด ์ด๋ฏธ fopen๋œ ํŒŒ์ผ ํฌ์ธํ„ฐ๋ฅผ ์žฌ์‚ฌ์šฉ ํ•˜๋Š”๊ฒƒ์ด ์ข‹๋‹ค.

fflush ํ•จ์ˆ˜๋Š” ์ด๋Ÿฐ์‹์œผ๋กœ fopen ํŒŒ์ผ์— ์—ฌ๋Ÿฌ๋ฒˆ ์“ฐ๊ธฐ ์ž‘์—…์„ ํ• ๋•Œ ์œ ์šฉํ•œ๋ฐ, ๊ฐ€๋” ๋ฒ„ํผ๋ฅผ ์ „๋ถ€ ์“ฐ์ง€๋ฅผ ๋ชปํ•˜๊ณ  ๋‚จ์•„์žˆ๋Š” ๊ฒฝ์šฐ๊ฐ€ ์žˆ๋Š”๋ฐ ์ด๋•Œ fflush๋ฅผ ํ˜ธ์ถœํ•ด์„œ ๋‚จ์€ ๋ฐ”์ดํŠธ๋ฅผ ์†Œ๋ชจํ•˜๋„๋ก ํ•œ๋‹ค.

ํ‘œ์ค€ ์ž…์ถœ๋ ฅ ํ•จ์ˆ˜ ์ถ”๊ฐ€

์ฐธ๊ณ ๋กœ gets, puts ํ•จ์ˆ˜๋Š” ๋ฒ„ํผ ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ ์ทจ์•ฝ์„ฑ ๋•Œ๋ฌธ์— C ํ‘œ์ค€์—์„œ ์ œ์™ธ๋ฌ๋‹ค ์นด๋”๋ผ
fgets, fputs๋Š” ํŒŒ์ผ ํ•จ์ˆ˜ ์ด์ง€๋งŒ ํ‘œ์ค€ ์ž…์ถœ๋ ฅ์— ๋” ์œ ์šฉํ•˜์—ฌ ์—ฌ๊ธฐ๋‹ค ์„œ์ˆ ํ•œ๋‹ค.

  • char * fgets(char *_Buffer, int _MaxCount, FILE *_Stream): \n์„ ํ—ˆ์šฉํ•˜๋Š” ์ž…๋ ฅ & ํ…์ŠคํŠธ ํŒŒ์ผ ์ฝ๊ธฐ

    • _Stream์„ stdin์œผ๋กœ ์„ค์ •ํ•˜๋ฉด _Buffer๋Š” ์ž…๋ ฅ์— ์‚ฌ์šฉ๋œ ๊ฒฐ๊ณผ๋ฅผ ์ €์žฅํ•  ์šฉ๋„๋กœ ์‚ฌ์šฉ๋œ๋‹ค

      scanf๋ž‘ ์ฐจ์ด๋Š” ๋ฐ”๋กœ \n์„ ํ•˜๋‚˜์˜ ์ž…๋ ฅ์œผ๋กœ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ๋‹ค. ์‚ฌ์šฉ์ž๊ฐ€ enterํ‚ค๋ฅผ ์ž…๋ ฅ ํ–ˆ๋Š”์ง€, ๊ทธ๋ฆฌ๊ณ  ์•„๋ฌด๋Ÿฐ ๊ฐ’์„ ์ž…๋ ฅํ•˜์ง€ ์•Š๊ณ  ๋„˜์–ด๊ฐ”๋Š”์ง€ ๋“ฑ์„ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋œ๋‹ค.

      ์ด๋•Œ ๋ฌธ์ž์—ด ๋์€ \n์„ ํฌํ•จํ•˜๋‹ˆ ๋์„ \0์œผ๋กœ ๋ฐ”๊พธ๋Š” ์ฒ˜๋ฆฌ๋ฅผ ํ•ด์•ผํ•œ๋‹ค.

      ๋ฌธ์ž์—ด๋กœ ๋ฐ–์— ๋ฐ˜ํ™˜์ด ์•ˆ๋˜์„œ ๋งŒ์•ฝ ํ˜• ๋ณ€ํ™˜์ด ํ•„์š”ํ•˜๋ฉด ์ถ”๊ฐ€์ ์œผ๋กœ fscanf๋‚˜ ์ด๋Ÿฐ๊ฑธ๋กœ ๋ฐ”๊พธ๋ฉด ๋œ๋‹ค.

      _MaxCount๋Š” ์ตœ๋Œ€ ๊ธธ์ด

      ๋ฐ˜ํ™˜๊ฐ’: ๋ฌธ์ž์—ด ๋ (\n)์˜ ์ฃผ์†Œ๊ฐ’, ์˜ค๋ฅ˜๋ผ๋ฉด null

      ๋งŒ์•ฝ ํŒŒ์ผ๋กœ ๋‹ค๋ฃจ๊ฒŒ ๋œ๋‹ค๋ฉด ๋ฌธ์ž์—ด์„ ์ฝ์„๋•Œ \n์„ ๊ธฐ์ค€์œผ๋กœ ์ฝ๊ธฐ ๋•Œ๋ฌธ์— ๊ฐœํ–‰์ด ์žˆ๋‹ค๋ฉด ์ฒซ์ค„๋งŒ ์ฝ๊ฒŒ ๋œ๋‹ค. ์ด๋•Œ๋Š” ํ•ด๋‹น ๋ฐ˜ํ™˜๊ฐ’์„ ์‚ฌ์šฉํ•ด์„œ ๋ฐ˜ํ™˜๊ฐ’+1 ๋ถ€ํ„ฐ ๋‹ค์‹œ ์ฝ๊ฒŒ ํ•˜์—ฌ ๋ชจ๋“  ์ค„์„ ๋๊นŒ์ง€ ์ฝ์„ ์ˆ˜ ์žˆ๊ฒŒ ํ•  ์ˆ˜๋„ ์žˆ๋‹ค,

      char str[100];
      fgets(str, sizeof(str), stdin);
      printf("%s", str);
  • int fputs(const char *_Buffer, FILE *_Stream): ๋ฌธ์ž์—ด์„ \n ๋‹จ์œ„๋กœ ์ถœ๋ ฅ & ํ…์ŠคํŠธ ํŒŒ์ผ ์“ฐ๊ธฐ

    • _Stream์„ stdout์œผ๋กœ ์„ค์ •ํ•˜๋ฉด _Buffer๋ฅผ ์ถœ๋ ฅํ•  ๋ฒ„ํผ๋กœ ์‚ฌ์šฉ๋œ๋‹ค.

      \n์ด ๋ฌธ์ž์—ด์— ๋์ด๋ฏ€๋กœ ๊ฐœํ–‰์ด ์—†๋Š” ๋ฒ„ํผ๋ฅผ ์ถœ๋ ฅํ•  ๋•Œ ์šฉ์ธํ•˜๊ธด ํ•œ๋ฐ ์ž˜ ์“ธ์ผ์€ ์—†๊ณ  ์‚ฌ์‹ค puts๋Š” ํŒŒ์ผ ์“ฐ๊ธฐ ํ• ๋•Œ ์ข€๋” ์ข‹์€ ํŽธ์ด๊ธด ํ•˜๋‹ค.

      ๋ฐ˜ํ™˜๊ฐ’: _Stream์— ์“ด ๋ฐ”์ดํŠธ ์ˆ˜, ์˜ค๋ฅ˜๋ผ๋ฉด 0

๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น & ์กฐ์ž‘ ํ•จ์ˆ˜

  • void * malloc(size_t _Size): ํž™ ์˜์—ญ์œผ๋กœ ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น

    • ์ฐธ๊ณ ๋กœ malloc ์€ ์‹คํŒจ ํ•  ์ˆ˜ ์žˆ๋‹ค. (๋ฌผ๋ฆฌ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์ด ๋ถ€์กฑํ•˜๋“ ์ง€ ํ•˜๋ฉด)
      ์ด๋•Œ ๋ฐ˜ํ™˜๊ฐ’์œผ๋กœ NULL์„ ๋ณด๋‚ด๋‹ˆ ์ฐธ๊ณ ํ•˜์ž
  • void * realloc(void *_Block, size_t _Size): ํž™ ์˜์˜ ๋ฉ”๋ชจ๋ฆฌ ํ™•์žฅ

    • ์ด๋ฏธ malloc ์œผ๋กœ ํ• ๋‹น๋œ ํž™ ์˜์—ญ์— ํฌ๊ธฐ๋ฅผ ํ™•์žฅํ•œ๋‹ค
      _Block์€ ํž™์— ํ• ๋‹น๋œ ํฌ์ธํ„ฐ์ด๊ณ  ๊ทธ๊ฑธ _Size ๋งŒํผ ํ™•์žฅ

      ๊ธฐ์กด์— ์žˆ๋˜ ๋ฐ์ดํ„ฐ๋Š” ๊ทธ๋Œ€๋กœ ๋ณด์กด๋˜๊ณ  ์ƒˆ๋กœ์šด ํฌ๊ธฐ๊ฐ€ ํ• ๋‹น๋œ๋‹ค.
      ๊ทธ๋ž˜์„œ ๊ฐ€๋ณ€๊ธธ์ด ๋ฆฌ์ŠคํŠธ ๋งŒ๋“ค๊ฑฐ๋‚˜ ํ• ๋•Œ ๋งŽ์ด ์‚ฌ์šฉ๋œ๋‹ค.

      realloc ์€ ๊ธฐ์กด์— ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋ฅผ ๋”ฐ๋ผ๊ฐ€์ง€ ์•Š๋Š”๋‹ค.
      ๊ทธ๋ž˜์„œ ์ƒˆ๋กœ ํ• ๋‹น๋œ ์ฃผ์†Œ๋Š” ๋ฐ˜ํ™˜๊ฐ’์œผ๋กœ ์•Œ ์ˆ˜ ์žˆ๊ฒŒ ๋œ๋‹ค.
      ๋‹ค๋งŒ ๊ธฐ์กด์— ์žˆ๋˜ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ free ์‹œํ‚ฌ ํ•„์š”๋Š” ์—†๋‹ค.
      ์ฆ‰ realloc์— ๋ฐ˜ํ™˜๊ฐ’์œผ๋กœ ๋‚˜์˜จ ์ฃผ์†Œ๊ฐ’์œผ๋กœ๋งŒ free ์‹œํ‚ค๋ฉด ๋œ๋‹ค.

      ํ•˜์ง€๋งŒ ๋งŒ์•ฝ realloc์ด ์‹คํŒจํ•œ ๊ฒฝ์šฐ NULL์„ ๋ฐ˜ํ™˜ํ•˜๋Š”๋ฐ ์ด๋•Œ๋Š” ๊ธฐ์กด์— ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ free ํ•ด์•ผ ๋œ๋‹ค.
      ์ฆ‰ malloc ์œผ๋กœ ํ• ๋‹นํ•œ ๊ธฐ์กด ํฌ์ธํ„ฐ ๊ฐ’์„ ์•Œ๊ณ  ์žˆ์–ด์•ผ ํ•œ๋‹ค๋Š” ์†Œ๋ฆฌ

  • void * memset(void *_Dst, int _Val, size_t _Size): ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํŠน์ • ๊ฐ’์œผ๋กœ ์ดˆ๊ธฐํ™”

    • _Dst ๋ฉ”๋ชจ๋ฆฌ ์˜์˜์—ญ์„ _Val ๊ฐ’์œผ๋กœ _Size ๋งŒํผ ์ดˆ๊ธฐํ™”

      _Size๊ฐ’์€ ๋ณดํ†ต ๊ตฌ์กฐ์ฒด ํฌ๊ธฐ๊ฐ€ ์˜จ๋‹ค

      ์Šคํƒ ์˜์—ญ์— ๊ฒฝ์šฐ Data a = {0} ๋“ฑ์œผ๋กœ 0 ์ดˆ๊ธฐํ™”๊ฐ€ ๊ฐ€๋Šฅํ•˜์ง€๋งŒ, ํž™์œผ๋กœ ์ดˆ๊ธฐํ™” ํ•œ ๊ฒฝ์šฐ์—๋Š” ์ดˆ๊ธฐ๊ฐ’ ํ• ๋‹น์ด ๋ถˆ๊ฐ€ ํ•˜๋‹ˆ memset์„ ํ™œ์šฉํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๋‹ค.

  • void * memmove(void *_Dst, const void *_Src, size_t _Size): ๋ฉ”๋ชจ๋ฆฌ ์ด๋™

    • _Src ๋ฉ”๋ชจ๋ฆฌ ์˜์—ญ์— _Size ๋งŒํผ์„ _Dst ์ฃผ์†Œ๋กœ ์˜ฎ๊น€

      ๋ฌธ์ž์—ด์„ ํฌํ•จํ•œ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฅธ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๋กœ ์˜ฎ๊ธด๋‹ค.
      ์Šคํƒ, ํž™ ์˜์—ญ ๊ตฌ๋ถ„ ์—†์ด ์˜ฎ๊ธธ ์ˆ˜ ์žˆ์ง€๋งŒ, ํž™ ์˜์—ญ์€ ์˜ฎ๊ธฐ๊ธฐ ์ด์ „ ์ฃผ์†Œ๋ฅผ free ์‹œ์ผœ์•ผํ•œ๋‹ค.

  • void * memcpy(void *_Dst, const void *_Src, size_t _Size)

    • _Src ๋ฉ”๋ชจ๋ฆฌ ์˜์—ญ์— _Size ๋งŒํผ์„ _Dst ์ฃผ์†Œ๋กœ ๋ณต์‚ฌ

      ๋ฌธ์ž์—ด์„ ํฌํ•จํ•œ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ๋‹ค๋ฅธ ๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ์— ๋ณต์‚ฌํ•œ๋‹ค.
      ์Šคํƒ, ํž™ ์˜์—ญ ๊ตฌ๋ถ„ ์—†์ด ์˜ฎ๊ธธ ์ˆ˜ ์žˆ์ง€๋งŒ, ํž™ ์˜์—ญ์€ ๋ณต์‚ฌํ•˜๊ธฐ ์ด์ „ ์ฃผ์†Œ๋ฅผ free ์‹œ์ผœ์•ผํ•œ๋‹ค.

๊ฐ€๋ณ€ ์ธ์ž ์„œ์‹ ๋ฌธ์ž ์ฒ˜๋ฆฌ ํ•จ์ˆ˜

va_start-va_end ๋ธ”๋ก ๋‚ด๋ถ€์— ์„œ์‹ ๋ฌธ์ž ์ฒ˜๋ฆฌ์šฉ ํ•จ์ˆ˜

  • int vprintf(const char *const _Format, va_list _ArgList): ์„œ์‹ ๋ฌธ์ž์—ด ์ถœ๋ ฅ

    • printf์— ๊ฐ€๋ณ€์ธ์ž ๋ž˜ํ•‘ํ•จ์ˆ˜
  • int vfprintf(FILE *const _Stream, const char *const _Format, va_list _ArgList): ์„œ์‹ ๋ฌธ์ž์—ด์„ ํŒŒ์ผ ์ŠคํŠธ๋ฆผ์œผ๋กœ ์ €์žฅ

    • fprintf์— ๊ฐ€๋ณ€์ธ์ž ๋ž˜ํ•‘ํ•จ์ˆ˜
  • int vsnprintf(char *const _Buffer, const size_t _BufferCount, const char *const _Format, va_list _ArgList): ๊ฐ€๋ณ€์ธ์ž ๋ฒ„ํผ ์ €์žฅ ํ•จ์ˆ˜

    • snprintf์— ๊ฐ€๋ณ€์ธ์ž ๋ž˜ํ•‘ํ•จ์ˆ˜
      ๋ฐ˜ํ™˜๊ฐ’: ์„œ์‹ ๋ฌธ์ž๋ฅผ ํ†ตํ•ด ๋งŒ๋“ค์–ด์ง€๋Š” ๋ฌธ์ž์—ด์— ๊ธธ์ด

๊ธฐํƒ€ ํ•จ์ˆ˜

  • sizeof(Any): ์ž๋ฃŒํ˜• ํฌ๊ธฐ๋ฅผ ๋ฐ˜ํ™˜
    • ์ฃผ์˜: ์ดˆ๊ธฐํ™”๋œ ๋ฉ”๋ชจ๋ฆฌ ํฌ๊ธฐ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š”๊ฒŒ ์•„๋‹˜!!!

      ์˜ˆ๋ฅผ ๋“ค์–ด, malloc ์œผ๋กœ 100 ํฌ๊ธฐ์— ํž™๊ณต๊ฐ„์„ ํ•˜๊ณ  ํ•ด๋‹น ํฌ์ธํ„ฐ์— sizeof ๊ฒฐ๊ณผ ๊ฐ’์„ ํ™•์ธ ํ•ด๋ณด๋ฉด 100์„ ๋ฐ˜ํ™˜ํ•˜๋Š”๊ฒŒ ์•„๋‹ˆ๋ผ ํฌ์ธํ„ฐ ํฌ๊ธฐ์ธ 8(x32๋Š” 4)์„ ๋ฐ˜ํ™˜ํ•œ๋‹ค.

์„œ์‹๋ฌธ์ž ์ข…๋ฅ˜

https://programfrall.tistory.com/91

๊ธฐํƒ€ ์‚ฌํ•ญ

  • 0์ด ์•„๋‹Œ ๋ชจ๋“  ์ˆ˜๋Š” ์ฐธ์ด๋‹ค

    int main(int argc, char const *argv[]) {
    	int a = 1;
    	int b = -1;
    	int c = 0;
    	if (a) {
    		printf("a๋Š” ์ฐธ");
    	}
    	if (b) {
    		printf("b๋Š” ์ฐธ");
    	}
    	if (c) {
    		printf("c๋Š” ๊ฑฐ์ง“");
    	}
    }

    js๋‚˜, python๊ณผ๊ฐ™์ด 0์ด ์•„๋‹Œ ๋ชจ๋“  ์ˆ˜๋Š” ์กฐ๊ฑด์‹์— ์ฐธ์„ ๋งŒ์กฑํ•œ๋‹ค.
    ์ด๋Ÿฌํ•œ ์‹์€ ํฌ์ธํ„ฐ(์ฃผ์†Œ) ์™€, ์ˆซ์žํ˜• ๋งŒ ๋น„๊ต๊ฐ€ ๋œ๋‹ค.

  • 0 == NULL
    ์ปดํŒŒ์ผ๋Ÿฌ ๋งˆ๋‹ค ์ •์˜๊ฐ€ ์ฌ๋” ๋‹ค๋ฅธ๋ฐ MSVC์— ๊ฒฝ์šฐ ์ง„์งœ๋กœ NULL ์ด 0์œผ๋กœ
    define ๋˜์–ด์žˆ๋Š”๋ฐ, gcc์— ๊ฒฝ์šฐ ((void*)0) ์œผ๋กœ ์„ ์–ธ ๋˜์–ด
    0์˜ ์ฃผ์†Œ๋ฅผ ๊ฐ€๋ฅดํ‚ค๋Š” ํฌ์ธํ„ฐ๋กœ ๋˜์–ด์žˆ๋‹ค.

    ๊ทธ๋ž˜์„œ GCC ๊ฐ™์€ ๊ฒฝ์šฐ ํฌ์ธํ„ฐ๊ฐ€ ์•„๋‹Œ ๋ณ€์ˆ˜๋“ค์„ NULL๋กœ ์ดˆ๊ธฐํ™” ํ•˜๋ ค๋ฉด (int) NULL
    ์ด๋Ÿฐ์‹์œผ๋กœ ํ˜• ๋ณ€ํ™˜ ํ•ด์•ผ ํ•œ๋‹ค.

  • ์™ธ๋ถ€ ๋ณ€์ˆ˜ ์ฐธ์กฐ

    externย intย tt;

    ๋‹ค๋ฅธ ์†Œ์ŠคํŒŒ์ผ์— ๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜๊ณ  ์‹ถ์„ ๋•Œ

  • ๋ฆฌ๋ˆ…์Šค๋Š” _s ํ•จ์ˆ˜(safe ํ•จ์ˆ˜)๋ฅผ ์“ธ ์ˆ˜ ์—†๋‹ค
    MSVC์—์„œ๋Š” _s ํ•จ์ˆ˜๋ฅผ ๊ฐ•์š”ํ–ˆ๋Š”๋ฐ, ์‹œ์‹ค ์ด๊ฑฐ ๋น„ํ‘œ์ค€ ์ด๋”๋ผ
    C99์—์„œ ํ‘œ์ค€์œผ๋กœ ์ง€์ • ๋˜์—ˆ์ง€๋งŒ ์—ฌ์ „ํžˆ ๋ฆฌ๋ˆ…์Šค์—์„œ๋Š” ์ง€์›์•ˆํ•˜๋”๋ผ
    ๋ฌผ๋ก  ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์„ค์น˜ํ•˜๋ฉด ๋˜์ง€๋งŒ ๊ธฐ๋ณธ ์ง€์›์€ ์•ˆ๋˜๋Š”๊ฑฐ๋‹ˆ ์ฐธ๊ณ ํ•˜์ž