๋ฌธ์์ด ์ ์ฅ/์ถ๋ ฅ ์ฒ๋ฆฌ
#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์ ๋ณด๋ด๋ ์ฐธ๊ณ ํ์
- ์ฐธ๊ณ ๋ก malloc ์ ์คํจ ํ ์ ์๋ค. (๋ฌผ๋ฆฌ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋ถ์กฑํ๋ ์ง ํ๋ฉด)
-
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์ ๊ฐ๋ณ์ธ์ ๋ํํจ์
๋ฐํ๊ฐ: ์์ ๋ฌธ์๋ฅผ ํตํด ๋ง๋ค์ด์ง๋ ๋ฌธ์์ด์ ๊ธธ์ด
- 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์์ ํ์ค์ผ๋ก ์ง์ ๋์์ง๋ง ์ฌ์ ํ ๋ฆฌ๋ ์ค์์๋ ์ง์์ํ๋๋ผ
๋ฌผ๋ก ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ค์นํ๋ฉด ๋์ง๋ง ๊ธฐ๋ณธ ์ง์์ ์๋๋๊ฑฐ๋ ์ฐธ๊ณ ํ์