์ด๋ฒ ํฌ์คํ ์์๋ ๋์ ๊ณผ ์ ์ ์ ๋ํด์ ์์ฑํด๋ณด๋ ค๊ณ ํฉ๋๋ค.
์์ค ์ฝ๋๋ฅผ ๋๋ฆด ๋ ํตํฉ๊ฐ๋ฐํ๊ฒฝ์ ์ปดํ์ผ๊ณผ ์คํ์ ๊ฑฐ์น๋ค.
์ปดํ์ผ ๊ณผ์ ์์ ์ฐ๋ฆฌ๊ฐ ์ง ์์ค ์ฝ๋๊ฐ ์ ๋๋ก ๋์๋์ง ์ดํด๋ณด๊ณ
์ด์์ด ์์ผ๋ฉด ์คํ ๋จ๊ณ๋ก ๋์ด๊ฐ๋ค. ์ฌ๊ธฐ์๋ ์ค๋ฅ๊ฐ ์์ผ๋ฉด ์ฝ์ ์ฐฝ์ ์คํ
๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํด์ค๋ค.
์ ์ (Static), ๋์ (Dynamic) ํ ๋น์ ๊ตฌ๋ถํ๋ ๊ธฐ์ค์ 'ํ๋ก๊ทธ๋จ ์คํ ์ค์
๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋นํ๋๊ฐ?' ์ด๋ค. ์ ์ ํ ๋น์ ์ปดํ์ผ ๋จ๊ณ์์ ํ์ํ ๋ฉ๋ชจ๋ฆฌ
๊ณต๊ฐ์ ํ ๋นํ๊ณ , ๋์ ํ ๋น์ ์คํ ๋จ๊ณ์์ ๊ณต๊ฐ์ ํ ๋นํด์ฃผ๋ ๊ฒ์ด๋ค.
์ง๊ธ๊น์ง๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ทธ๋ฅ ๋ชฝ๋ฑ๊ทธ๋ ค '๋ณ์๋ฅผ ์ ์ฅํ๋ ๊ณต๊ฐ. ๋ฐฉ ํ๋ํ๋๋ง๋ค ์ฃผ์๊ฐ ์๋ค'
์ ๋๋ก ๋ค๋ฃจ์๋ค. ํ์ง๋ง ๋ฉ๋ชจ๋ฆฌ๋ ๊ทธ ํ์ฉ๊ณผ ๊ธฐ๋ฅ์ ๋ฐ๋ผ ํฌ๊ฒ 4๊ฐ์ง ์ข
๋ฅ๋ก ๊ตฌ๋ถ๋๋ค.
Code/Data/Stack/Heap
-> ํจ์, ์์ ์ ์ฅ
ํจ์์ ์์, ์คํํ ํ๋ก๊ทธ๋จ์ ์ฝ๋๊ฐ ์ ์ฅ๋๋ ๊ณต๊ฐ์ด๋ค.
ํจ์๋ ์์๋ ์ปดํ์ผ ๋จ๊ณ์์ ๊ฒ์ฌ๋ฅผ ๋ง์น๊ณ ์ ์ฅ๋๋ฏ๋ก ์ด ๊ณณ์ ์ ์ ๋ฉ๋ชจ๋ฆฌ์ด๋ค.
-> ์ ์ญ/์ ์ ๋ณ์ ์ ์ฅ
์ ์ญ ๋ณ์์ ์ ์ (Static) ๋ณ์๊ฐ ์ ์ฅ๋๋ ์์ญ์ด๋ค.
Code ์์ญ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ปดํ์ผ ๋จ๊ณ์์ ๊ฒ์ฌ๋ฅผ ๋๋ง์น๊ณ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ด ์ด๋ฃจ์ด์ง๋ค.
์ถ๊ฐ์ ์ผ๋ก C,C++์์ ์ ์ญ ๋ณ์์ ์ ์ ๋ณ์๋ฅผ ์ ์ธํ๊ฒ ๋๋ฉด ๋ฐ๋ก ์ด๊ธฐํํ์ง ์์๋ 0์ผ๋ก
์๋ ์ด๊ธฐํ ๋์ด ์๋ค๋ ์ฌ์ค์ ๋ฐ๊ฒฌํ ์ ์๋ค. ์ด๋ Stack ์์ญ์ ์ ์ฅ๋๋ ์ง์ญ ๋ณ์๋ ๋งค๊ฐ ๋ณ์์ ๋ฌ๋ฆฌ ์ ์ญ ๋ณ์์ ์ ์ ๋ณ์๋ Data ์์ญ์ ์ ์ฅ๋๊ธฐ ๋๋ฌธ์ด๋ค.
-> ์ง์ญ/๋งค๊ฐ ๋ณ์ ์ ์ฅ
์ง์ญ ๋ณ์์ ๋งค๊ฐ๋ณ์๊ฐ ์ ์ฅ๋๋ ๊ณณ์ด๋ค. ์ฆ ํต์์ ์ผ๋ก ์ฐ๋ฆฌ๊ฐ ๋ณ์๋ผ๊ณ ๋ถ๋ฅด๋ ๊ฒ๋ค์
์ ์ธํ๋ฉด ์ด ์์ญ์์ ๊ณต๊ฐ์ ํ ๋นํด์ค๋ค.
๐ค ์ ๋์ ๋ฉ๋ชจ๋ฆฌ์ผ๊น?
์ง์ญ ๋ณ์์ ๋งค๊ฐ ๋ณ์๋ ์ ์ธ๋ ํจ์ ๋ด์์๋ง ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
๊ทธ ํจ์๋ฅผ ๋ฒ์ด๋๋ฉด ํ ๋น๋ ๊ณต๊ฐ์ ๋ฐ๋ฉํ๊ณ ์ฌ๋ผ์ ธ์ผ ํ๋ค.
ํ๋ก๊ทธ๋จ ์คํ ๊ณผ์ ์์ ์ด๋ฐ ์ผ์ ํจ์ ํ๋๊ฐ ์ฌ๋ผ์ง ๋๋ง๋ค ๋น๋ฒํ๊ฒ ์ผ์ด๋๋ค.
๊ฐ์ฅ ํ๋ฐํ๊ฒ ๊ณต๊ฐ์ด ์ฐจ๊ณ ๋น์์ง๋ ๊ณณ์ธ ์
์ด๋ค.
๋์ ํ ๋น์ ๋ฐ์์ค๋ ์ฅ์๋ค. ๋์ ํ ๋น ๋ฐ์ ๊ณต๊ฐ์ ์ฐ๋ฆฌ๊ฐ ๋ณ๋์ ๋ช
๋ น์ด(C๋ผ๋ฉด free(), C++์ด๋ผ๋ฉด Delete())๋ฅผ ์ด์ฉํด ํด์ ํด์ฃผ๊ธฐ ์ ๊น์ง๋ ์ฌ๋ผ์ง์ง ์๋๋ค.
๋์ ํ ๋น์ ํ๋ก๊ทธ๋จ ์คํ ์ค์ ๋ฐ์ํ๋ฏ๋ก Heap์ ๋์ ๋ฉ๋ชจ๋ฆฌ์ด๋ค.
๋ฉ๋ชจ๋ฆฌ์ ์์ญ์ ๋ํด์ ์ ๋ฆฌํ๋๋ผ ์ด์ผ๊ธฐ๊ฐ ๊ธธ์ด์ก๋๋ฐ ์ด์ ์ ์ ํ ๋น์ ๋ํด์ ์ ๋ฆฌํด๋ณด๋ ค๊ณ ํ๋ค
์ ์ ํ ๋น์ ์๊น ์์์๋ ์์ฑํ์ง๋ง ์ปดํ์ผ ๋จ๊ณ์์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋น๋ฐ๋ ๊ฒ์ด๋ค.
๋ํ์ ์ธ ์์๋ก๋ ๋ณ์๋ ๋ฐฐ์ด์ ์ ์ธํ๋ ๊ฒ์ ๋ค ์ ์๋ค.
ํ ๋ฒ ์ปดํ์ผ์ ์์ํ๋ฉด ๊ทธ๋๋ถํฐ๋ ๋ ์ด์ ์ถ๊ฐ์ ์ผ๋ก ๋ฐฐ์ด์ ์ ์ธํ ์ ์๋ค.
int i, j;
int buffer [100];
char name[] = "data structure";
ํ๋ก๊ทธ๋จ ์คํ ๋์ค์ ๋์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ฉฐ ์ปดํ์ผ ํ ๋ ๋ฏธ๋ฆฌ ์ ํด์ง๋ ๊ฒ์ด ์๋
์คํ ๋จ๊ณ์์ ๊ณต๊ฐ์ด ์ ํด์ง๋ ๊ธฐ๋ฅ์ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ ๋งค์ฐ ํจ์จ์ ์ด๋ค.
์ปดํ์ผ ํ ๋ ๋ฏธ๋ฆฌ ์์ ํด์ง๋ค๋ ํจ์จ์ ์ด๋ผ๋ ์ฅ์ ์ ๊ฐ์ง๊ณ ์์ผ๋ ์์ค์ฝ๋๊ฐ ๋งค์ฐ ๋ณต์กํ๋ค๋ ๋จ์ ์ ๊ฐ์ง๊ณ ์๋ค.
#include <stdlib.h> //๋์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ํจ์ ๋ถ๋ฌ์ค๊ธฐ
...
int *ptr = NULL;
int size = 100;
ptr = (int*) malloc (sizeof(int)*size); // malloc() ๋ฉ๋ชจ๋ฆฌ ํ ๋น
...
free ( ptr ); // ๋ฉ๋ชจ๋ฆฌ ํด์
#include <stdlib.h>
ํค๋ ์์ ์๋ ํจ์์ด๋ฉฐ malloc ํจ์๋ ๋ฐ์ดํธ ๋จ์๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํฉ๋๋ค.
๋ฉ๋ชจ๋ฆฌ ๋ธ๋ญ์ ์ฒซ ๋ฒ์งธ ๋ฐ์ดํธ์ ๋ํ ์ฃผ์๋ฅผ ๋ฐํํ๋๋ฐ, ์์ฒญ ๊ฐ์ด ์์ผ๋ฉด NULL์ ๋ฐํํฉ๋๋ค.
intํ ๋ฐ์ดํฐ ์ ์ฅ์ ์ํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ํด์๋
int *p;
p = (int*) malloc(sizeof(int));
charํ ๋ฐ์ดํฐ ์ ์ฅ์ ์ํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ํด์๋
char *p;
p = (char*) malloc( sizeof(char));
void free(void *ptr);
์์ ๊ฐ์ ํํ๋ก ptr์ ํ ๋น๋์๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ์์คํ
์ ๋ฐ๋ฉํ๋ค.
๋ฐ๋ฉํ ๋๋ value๋ฅผ ์จ์ค์ผํ๊ธฐ ๋๋ฌธ์ *๋ฅผ ๋ถ์ธ๋ค.
์ค์ ๋ก๋ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉ๋๋ค.
int *p;
p = (int*) malloc(sizeof(int));
free(p);
์ด๋ ๋ฏ ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ 'ํฌ์ธํฐ'๋ก ์ด๋ฃจ์ด์ง๋ค.
ํฌ์ธํฐ๊ฐ ๊ฐ์ด ํ ๋น๋ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ฅผ ํ์ฉํ๋ ๊ฒ์ ๋น์ฐํ๋ฉฐ ๋์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ฌ์ฉ๋๊ณ ๋ค์ ๋ฐ๋ฉ๋๋ ๊ณผ์ ์ ๋ณด๋๋ก ํ์
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int *pi = NULL; char *pc = NULL;
pi = (int *) malloc ( sizeof(int) ); // ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
if ( pi == NULL ) { printf("๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์ค๋ฅ\n"); exit(1); }
*pi = 100; // ๋์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ
printf("%d\n", *pi);
free(pi); // ๋์ ๋ฉ๋ชจ๋ฆฌ ๋ฐ๋ฉ
pc = (char *) malloc ( sizeof(char) ); // ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
if ( pc == NULL ) { printf("๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์ค๋ฅ\n" ); exit(1); }
*pc = 'm'; // ๋์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ
printf("%c\n", *pc);
free(pc); // ๋์ ๋ฉ๋ชจ๋ฆฌ ๋ฐ๋ฉ
return 0;
}
์ค์ ๊ฐ์ ์ง์ ํ์ง ์๊ณ pi, pc๋ง์ ๊ฐ์ ํ๋ค. mallocํจ์๋ก ๋์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ณ ์ค์ ๋ก ์ฌ์ฉํ๋ค.
๊ทธ๋ฆฌ๊ณ ๋ง์ง๋ง์ผ๋ก freeํจ์๋ก ๋์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฐ๋ฉํ๋ค!!
ํฌ์ธํฐ๋ก ๋ฐฐ์ด์ ์ง๋ชฉํ๋ ๋ฐฉ๋ฒ๋ ์ด๋ ต์ง ์๋ค.
#include <stdio.h>
#include <malloc.h>
int main(void) {
int i, size=5;
int *arr;
arr = (int*) malloc ( sizeof(int) * size );
for ( i=0; i<size; i++ ) {
arr[i] = i;
}
for ( i=0; i<size; i++ ) {
printf("%d\n", *(arr+i));
}
free (arr);
return 0;
}
void *calloc(size_t n, size_t size);
0์ผ๋ก ์ด๊ธฐํ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ ํจ์๋ค.
void *realloc(void *memblock, size_t size);
ํ ๋นํ์๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ๋ ๊ฒ์ด๋ค.
malloc์์ ์ง์ ํด์คฌ๋ ์ฌ์ด์ฆ๋ฅผ ๋ค์ ํค์ฐ๊ฑฐ๋ ์ค์ด๋ ์์
์ด ํ์ํ ๋ ์ด๋ค.
int *p;
p = (int*) malloc (5 * sizeof(int));
p = (int*) realloc (p, 7 * sizeof(int));