1. ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ข ๋ฅ
C ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ฉด, ๋ ๊ฐ์ง ์ ํ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ํ ๋น๋๋ค.
- stack ๋ฉ๋ชจ๋ฆฌ
- ์ปดํ์ผ๋ฌ์ ์ํด ์๋ฌต์ ์ผ๋ก ํ ๋น๊ณผ ๋ฐํ์ด ์ด๋ฃจ์ด์ง
void func() {
int x; // ์คํ์ int ํ์ ์ ์ธ
// rest of code
}
- heap ๋ฉ๋ชจ๋ฆฌ
- ๋ชจ๋ ํ ๋น๊ณผ ๋ฐํ์ด ํ๋ก๊ทธ๋๋จธ์ ์ํด ๋ช ์์ ์ผ๋ก ์ฒ๋ฆฌ๋จ
void func() {
int *x = (int*) malloc(sizeof(int));
// rest of code
}
ํ ํ์ ์คํ๊ณผ ํ ํ ๋น์ด ๋ชจ๋ ๋ฐ์ํ๋ค.
- ์ปดํ์ผ๋ฌ๊ฐ ํฌ์ธํฐ ๋ณ์์ ์ ์ธ
int *x๋ฅผ ๋ง๋๋ฉด ์ ์ ํฌ์ธํฐ๋ฅผ ์ํ ๊ณต๊ฐ์ ํ ๋นํด์ผ ํ๋ค. - ํ๋ก๊ทธ๋จ์ด
malloc()์ ํธ์ถํ์ฌ ์ ์๋ฅผ ์ํ ๊ณต๊ฐ์ ํ์ผ๋ก๋ถํฐ ์๊ตฌํ๋ค. - ์ฑ๊ณตํ ๊ฒฝ์ฐ ๊ทธ ์ ์์ ์ฃผ์๋ฅผ ๋ฐํ, ์คํจํ ๊ฒฝ์ฐ
NULL์ ๋ฐํ
2. malloc() ํจ์
ํ์ ์์ฒญํ ๊ณต๊ฐ์ ํฌ๊ธฐ๋ฅผ ๋๊ฒจ ์ฃผ๋ฉด, ์ฑ๊ณตํ์ ๊ฒฝ์ฐ ์๋ก ํ ๋น๋ ๊ณต๊ฐ์ ๋ํ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉ์์๊ฒ ๋ฐํํ๊ณ , ์คํจํ์ ๊ฒฝ์ฐ NULL์ ๋ฐํํ๋ ๊ฐ๋จํ ํจ์.
malloc() ํจ์๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด stdlib.h๋ฅผ include ํด์ผ ํ๋ค.
malloc() ํจ์์ ์ธ์๋ size_t ํ์
์ด๊ณ ์ด ๋ณ์๋ ํ์ ๊ณต๊ฐ์ ํฌ๊ธฐ๋ฅผ ๋ฐ์ดํธ ๋จ์๋ก ํ์ํ ๊ฒ์ด๋ค. ์ซ์๋ฅผ ์ง์ ์ฐ์ง ์๊ณ sizeof() ํจ์๋ฅผ ํตํด ์ด๋ค.
malloc() ํจ์๋ void ํ์
์ ๋ํ ํฌ์ธํฐ๋ฅผ ๋ฐํํ๋ค. ์ฃผ์๋ง ๋๊ฒจ์ฃผ๊ณ ํด๋น ์ฃผ์์ ์ด๋ค ํ์
์ ์๋ฃ๋ฅผ ์ ์ฅํ ์ง๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ๊ฒฐ์ ํ๊ฒ ํ๋ ์ ํ์ ์ธ C ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ์์ด๋ค.
3. free() ํจ์
๋ ์ด์ ์ฌ์ฉ๋์ง ์๋ ํ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํ๊ธฐ ์ํด ํ๋ก๊ทธ๋๋จธ๋ free()๋ฅผ ํธ์ถํ๋ค.
int *x = malloc(10 * sizeof(int));
// rest of code
free(x);
ํ๊ฐ์ ์ธ์ malloc()์ ์ํด ๋ฐํ๋ ํฌ์ธํฐ๋ฅผ ๋ฐ๋๋ค. ํ ๋น๋ ์์ญ์ ํฌ๊ธฐ๋ ์ ๋ฌ๋์ง ์๋๋ค. ๊ทธ ํฌ๊ธฐ๋ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์๊ณ ์์ด์ผ ํ๋ค. ์ด ํฌ๊ธฐ๋ฅผ ์ด๋ป๊ฒ ์ ์ ์์๊น?
malloc()์ด๋calloc()ํจ์๋ฅผ ํธ์ถํ์ฌ ๋์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ฉด, ์ค์ ๋ก ์์ฒญ๋ ํฌ๊ธฐ๋ณด๋ค ์ฝ๊ฐ ๋ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ ๋น๋ฉ๋๋ค. ์ด ์ถ๊ฐ๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์๋ ๋ฉํ๋ฐ์ดํฐ ์ ๋ณด๊ฐ ์ ์ฅ๋๋ฉฐ, ์ฌ๊ธฐ์๋ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ํฌ๊ธฐ, ์ฌ์ฉ ์ฌ๋ถ ๋ฑ์ ์ ๋ณด๊ฐ ํฌํจ๋ฉ๋๋ค. ์ด๋ฌํ ๋ฉํ๋ฐ์ดํฐ๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ด ํด์ ๋์ด์ผ ํ ๋free()ํจ์๊ฐ ๋ช ๋ฐ์ดํธ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํด์ผ ํ๋์ง ์ ์ ์๊ฒ ํด์ค๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ด ๋ฉํ๋ฐ์ดํฐ๋ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก ๋ฐ๋ก ์์ ์์นํ๊ฒ ๋ฉ๋๋ค.

struct malloc_chunk {
INTERNAL_SIZE_T prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
์ด ์ฝ๋๋ C ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์
malloc()ํจ์์์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ์ฌ์ฉ๋๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ธmalloc_chunk์ ์ ์์ ๋๋ค.malloc_chunk๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ตฌ์กฐ์ฒด๋ก, ๊ฐ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ์ํ์ ๊ด๋ จ๋ ์ ๋ณด๋ฅผ ํฌํจํฉ๋๋ค. ๊ตฌ์ฒด์ ์ผ๋ก ๋ค์๊ณผ ๊ฐ์ ์ ๋ณด๋ค์ด ์ ์ฅ๋ฉ๋๋ค:
prev_size: ์ด ํ๋๋ ํ์ฌ ๋ธ๋ก์ด ํด์ ๋ ์ํ๋ผ๋ฉด ๋ฐ๋ก ์์ ์์นํ ๋ธ๋ก์ ํฌ๊ธฐ๋ฅผ ์ ์ฅํฉ๋๋ค. ํ์ฌ ๋ธ๋ก์ด ์ฌ์ฉ ์ค์ด๋ฉด ์ด ํ๋๋ ๋ฌด์๋ฉ๋๋ค.size: ์ด ํ๋๋ ํ์ฌ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ์ ์ฒด ํฌ๊ธฐ๋ฅผ ์ ์ฅํฉ๋๋ค. ์ด ํฌ๊ธฐ์๋ ๋ฉํ๋ฐ์ดํฐ์ ํฌ๊ธฐ๋ ํฌํจ๋๋ฉฐ, ๋ํ ๋ธ๋ก์ ํ ๋น ์ํ์ ๋ํ ์ ๋ณด๋ ํจ๊ป ์ ์ฅ๋ฉ๋๋ค. (๋ณดํต ๋ง์ง๋ง ๋นํธ๋ฅผ ์ฌ์ฉํ์ฌ ๋ธ๋ก์ด ์ฌ์ฉ ์ค์ธ์ง ์๋์ง๋ฅผ ํ์ํฉ๋๋ค)fd์bk: ์ด๋ค ํ๋๋ ๋๋ธ ๋งํฌ๋ ๋ฆฌ์คํธ์ ํฌ์๋(fd) ๋ ธ๋์ ๋ฐฑ์๋(bk) ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํต๋๋ค. ์ด๋ค์malloc_chunk๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ํด์ ๋ฆฌ์คํธ(free list)์ ์์นํ ๊ฒฝ์ฐ์๋ง ์ฌ์ฉ๋ฉ๋๋ค. ์ด ๋ฆฌ์คํธ๋ ํ์ฌ ์ฌ์ฉ๋์ง ์๊ณ ํด์ ๋ ์ํ์ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก๋ค์ ๊ด๋ฆฌํฉ๋๋ค.fd_nextsize์bk_nextsize: ์ด๋ค ํ๋๋ ํฐ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ๊ฒฝ์ฐ์๋ง ์ฌ์ฉ๋๋ฉฐ, ๋ค์ ํฌ๊ธฐ์ ๋ ํฐ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ๊ฐ๋ฆฌํต๋๋ค.
malloc()ํจ์๊ฐ ํธ์ถ๋๋ฉด, ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก ์ ์ฒด๊ฐ ํ ๋น๋๊ณ ๋ฉํ๋ฐ์ดํฐ ์์ญ์๋ ํด๋น ๋ธ๋ก์ ํฌ๊ธฐ ์ ๋ณด ๋ฑ์ด ์ ์ฅ๋ฉ๋๋ค. ๊ทธ๋ฐ ๋ค์ ํจ์๋ ์ฌ์ฉ์ ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋ ์์ญ์ ์์ ์ฃผ์, ์ฆ ๋ฉํ๋ฐ์ดํฐ ๋ฐ๋ก ๋ค์์ ์ฃผ์๋ฅผ ๋ฐํํฉ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉดfree()ํจ์๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ํด์ ํ ๋ ํด๋น ๋ธ๋ก์ ํฌ๊ธฐ๋ฅผ ์ ์ ์์ต๋๋ค.free()ํจ์๊ฐ ํธ์ถ๋๋ฉด, ํด๋น ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋ฐ์๋ค์ด๊ณ ๋ฉํ๋ฐ์ดํฐ ์์ญ์ผ๋ก โ๋ค๋ก ๊ฑธ์ด๊ฐโ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ํฌ๊ธฐ๋ฅผ ํ์ธํ ํ ๊ทธ ํฌ๊ธฐ๋งํผ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํฉ๋๋ค.
4. ํํ ์ค๋ฅ
๋ฉ๋ชจ๋ฆฌ ํ ๋น ์์ด๋ฒ๋ฆฌ๊ธฐ
char *src = "hello";
char *dst;
strcpy(dst, src); // ํ ๋น์ด ๋์ด ์์ง ์์. segfault.
Segmentation Fault๋ ํ๋ก๊ทธ๋จ์ด ์์ ์ด ์ ๊ทผ ๊ถํ์ด ์๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์ ๊ทผํ๋ ค๊ณ ์๋ํ ๋ ๋ฐ์ํ๋ ์ค๋ฅ. ์์ธํ ๋ด์ฉ์ OSTEP 16 Segmentation์์ ์์๋ณด์.
๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ถ์กฑํ๊ฒ ํ ๋น๋ฐ๊ธฐ
char *src = "hello";
char *dst = malloc(strlen(src)); // ๋ถ์กฑํ๊ฒ ํ ๋น
strcpy(dst, src);
Buffer Overflow. ๊ตฌํ ๋ฐฉ์์ ๋ฐ๋ผ ์ ์์ ์ผ๋ก ์๋ํ ์๋ ์๋ค. ํ๋ก๊ทธ๋จ์ด ํ ๋ฒ ์ฌ๋ฐ๋ฅด๊ฒ ์คํ๋๋ค๊ณ ํ๋๋ผ๊ณ , ํ๋ก๊ทธ๋จ์ด ์ฌ๋ฐ๋ฅด๋ค๋ ๊ฒ์ ์๋ฏธํ์ง๋ ์๋๋ค.
๋ค์๊ณผ ๊ฐ์ด ์์ฑํด์ผ ์ฌ๋ฐ๋ฅธ ์ฝ๋๋ค.
char *src = "hello";
char *dst = malloc(strlen(src) + 1);
if (dst != NULL) {
strcpy(dst, src);
}
ํ ๋น๋ฐ์ ๋ฉ๋ชจ๋ฆฌ ์ด๊ธฐํํ์ง ์๊ธฐ
malloc()์ ํธ์ถํด์ ์๋ก ํ ๋น๋ฐ์ ๋ฐ์ดํฐ ํ์
์ ๊ฐ์ ๋ฃ์ด์ผ ํ๋๋ฐ ๊ทธ๋ฅ ์ฝ์ผ๋ฉด? ํ์ผ๋ก๋ถํฐ ์ ์ ์๋ ๊ฐ์ ์ฝ๋ ์ผ(uninitialized read)์ด ์๊ธด๋ค.
๋ฉ๋ชจ๋ฆฌ ํด์ ํ์ง ์๊ธฐ
memory leak. ์ฅ์๊ฐ ์คํ๋๋ ์์ฉ ํ๋ก๊ทธ๋จ์ด๋ ์ด์์ฒด์ ์์ฒด์ ๊ฐ์ ์์คํ ํ๋ก๊ทธ๋จ์์ ํฐ ๋ฌธ์ ๋ค.
Garbage Collector๊ฐ ์์ด๋ ์ด ๋ฌธ์ ๋ฅผ ํผํด๊ฐ ์ ์๋ค. ๋ฉ๋ชจ๋ฆฌ ์ฒญํฌ์ ๋ํ ์ฐธ์กฐ๊ฐ ์กด์ฌํ๋ฉด, ์ด๋ GC๋ ๊ทธ ์ฒญํฌ๋ฅผ ํด์ ํ์ง ์์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์ ํ๋์ ์ธ ์ธ์ด์์๋ ๋ฉ๋ชจ๋ฆฌ ๋์๋ ์ฌ์ ํ ๋ฌธ์ ๊ฐ ๋๋ค.
ํ ๋ฐ์ดํธ๋ผ๋ ๋ช ์์ ์ผ๋ก ํ ๋น๋ฐ์์ผ๋ฉด ํด์ ํ๋ ์ต๊ด์ ๋ค์ด๋๋ก ํ์.
๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ด ๋๋๊ธฐ ์ ์ ๋ฉ๋ชจ๋ฆฌ ํด์ ํ๊ธฐ
dangling pointer.
์ฌ๊ฐํ ์ค์์ด๋ค. ์ฐจํ ๊ทธ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ฉด ํ๋ก๊ทธ๋จ์ ํฌ๋์ ์ํค๊ฑฐ๋ ์ ํจ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ๋ฎ์ด์ธ ์ ์๋ค. free()๋ฅผ ํธ์ถํ๊ณ ๋ค๋ฅธ ์ฉ๋๋ก malloc()์ ํธ์ถํ๋ ๊ฒฝ์ฐ, ์๋ชป ํด์ ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฌ์ฉํ๊ฒ ๋๋ค.
๋ฐ๋ณต์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ํด์ ํ๊ธฐ
double free.
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
chunk์ ๋ฉํ๋ฐ์ดํฐ ์ผ๋ถ์ด๋ค. ๋๋ธ ๋งํฌ๋๋ฆฌ์คํธ๋ฅผ ๋ง๋๋ ๋ฐ ์ฐ์ธ๋ค.
์ด ๋งํฌ๋๋ฆฌ์คํธ๋ free()๋ ์ฒญํฌ๋ค์ ๋ชจ์๋๋ ๋ฆฌ์คํธ์ด๋ค. ๋ค์์ ๊ฐ์ ์ฌ์ด์ฆ์ ํ ๋น์ด ๋ ๊ฒฝ์ฐ ๋น ๋ฅด๊ฒ ์ฌํ ๋น ํ ์ ์๋๋ก ํ๋ค.
double free๊ฐ ์ผ์ด๋๋ฉด ์ด ๋งํฌ๋๋ฆฌ์คํธ์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ ๋ ๋ฒ ๋ค์ด๊ฐ๋ค.
ํ๋ก๊ทธ๋๋จธ์ ์๋์๋ ๋ค๋ฅด๊ฒ, ๋ณ์ ์ฌ๋ฌ ๊ฐ๊ฐ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ ํ๊ฒ ๋์ด ๋ฒ๊ทธ๊ฐ ๋ฐ์ํ๋ค.
free() ์๋ชป ํธ์ถํ๊ธฐ
malloc() ๋ฐ์ ํฌ์ธํฐ๋ง ์ ๋ฌํด์ผ ํ๋ค. invalid frees๋ ๋งค์ฐ ์ํํ๋ค(undefined behavior).
5. ์ด์์ฒด์ ์ ์ง์
malloc()๊ณผ free()๋ ์์คํ
์ฝ์ด ์๋๋ผ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํจ์์ด๋ค. malloc()๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์์คํ
์๊ฒ ๋ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๊ตฌํ๊ณ ๋ฐํํ๋ ์์คํ
์ฝ(brk, sbrk)์ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌ์ถ๋๋ค.
brk์sbrk๋ ์ด์์ฒด์ ๊ฐ ์ ๊ณตํ๋ ์์คํ ํธ์ถ์ ๋๋ค. ์ด๋ค์ ํ๋ก์ธ์ค์ ํ ์์ญ์์ ์ฌ์ฉํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ์ ์์ ๊ด๋ฆฌํฉ๋๋ค.brk๋ ํ๋ก๊ทธ๋จ์ ํ ๋, ์ฆ โbreakโ ์์น๋ฅผ ์ค์ ํ๋ ์์คํ ํธ์ถ์ ๋๋ค.brk์ ์ฃผ์ด์ง ์ธ์๋ ํ ์์ญ์ ์๋ก์ด ๋์ ์ง์ ํฉ๋๋ค. ์ด ๊ฐ์ด ํ์ฌ break๋ณด๋ค ํฌ๋ค๋ฉด, ์ด์์ฒด์ ๋ ํ ์์ญ์ ํ์ฅํ๊ณ , ์ด ๊ฐ์ด ํ์ฌ break๋ณด๋ค ์๋ค๋ฉด, ์ด์์ฒด์ ๋ ํ ์์ญ์ ์ถ์ํฉ๋๋ค. ๋ค์ ๋งํด,brk๋ ์ด์์ฒด์ ์๊ฒ ํ๋ก์ธ์ค์ ํ ์์ญ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ๋๋ก ์์ฒญํ๋ ํจ์์ ๋๋ค.brk์ ๋น์ทํ๊ฒ,sbrk๋ ํ ์์ญ์ ๊ด๋ฆฌํ๋ ์์คํ ํธ์ถ์ ๋๋ค. ํ์ง๋งsbrk๋ ์๋ก์ด break ์์น๋ฅผ ์ง์ ์ง์ ํ๋ ๋์ , ํ์ฌ break ์์น์์์ ์๋์ ์ธ ๋ณํ๋ฅผ ์ง์ ํฉ๋๋ค. ์ฆ,sbrk์ ์ฃผ์ด์ง ์ธ์๋ ํ์ฌ break ์์น์ ๋ํด์ง ํฌ๊ธฐ๋ฅผ ๋ํ๋ ๋๋ค. ์ด๋ค ์์คํ ํธ์ถ์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๋ผ์ด๋ธ๋ฌ๋ฆฌ(์๋ฅผ ๋ค์ด,malloc์free)๊ฐ ์ด์์ฒด์ ๋ก๋ถํฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฒญํ๊ฑฐ๋ ๋ฐํํ ๋ ์ฌ์ฉ๋ฉ๋๋ค. ๋ฐ๋ผ์ ์ผ๋ฐ์ ์ผ๋ก๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ง์ ์ฌ์ฉํ๋ ๊ฒ์ด ์๋๋ผ, ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ๋ด๋ถ์ ์ผ๋ก ์ฌ์ฉํฉ๋๋ค.brk์sbrk๋ฅผ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ง์ ์ฌ์ฉํ๋ ค๊ณ ํ๋ฉด, ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ด๋ถ ์ํ์ ์ถฉ๋์ด ๋ฐ์ํ ์ ์์ต๋๋ค. ์ด๋ ๋ฉ๋ชจ๋ฆฌ ๋ฌธ์ ๋ฅผ ์ผ์ผํฌ ์ ์์ผ๋ฏ๋ก, ํ๋ก๊ทธ๋๋จธ๋ ๋์malloc๊ณผfree์ ๊ฐ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ณ ํด์ ํด์ผ ํฉ๋๋ค.
mmap() ํจ์๋ฅผ ํตํด ์ด์์ฒด์ ๋ก๋ถํฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ป๋ ๋ฐฉ๋ฒ๋ ์๋ค.
ํน์ ํ์ผ๊ณผ ์ฐ๊ฒฐ๋์ง ์์ anonymous ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์์ฑํ๋ค. swap space์ ์ฐ๊ฒฐ๋๋ฉฐ, ํ๊ณผ ์ ์ฌํ๊ฒ ์ทจ๊ธ๋๊ณ ๊ด๋ฆฌ๋๋ค.
6. ๊ธฐํ ํจ์๋ค
calloc()
- ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ณ ์ด๋ฅผ 0์ผ๋ก ์ด๊ธฐํํ์ฌ ๋ฐํํ๋ ํจ์
realloc()
- ์ด๋ฏธ ํ ๋น๋ ๊ณต๊ฐ์ ์ถ๊ฐ์ ์ธ ๊ณต๊ฐ์ด ํ์ํ ๋ ์ ์ฉํ ํจ์
- ๋ ํฐ ์๋ก์ด ์์ญ์ ํ๋ณดํ๊ณ , ์ด์ ์์ญ์ ๋ด์ฉ์ ๋ณต์ฌํ ํ์ ์๋ก์ด ์์ญ์ ๋ํ ํฌ์ธํฐ๋ฅผ ๋ฐํํ๋ค.