* malloc ํจ์, free ํจ์
๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ณ , ํด์ ํ๋ malloc๊ณผ freeํจ์๋ stdlib.h ํค๋ํ์ผ๋ด์ ์ ์๋์ด ์๋ค.
malloc (Meomory Allocation) : ์ฌ์ฉํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ๋ณดํ๋๋ก ํด์ค๋ค. ์ด๋ ๊ณต๊ฐ์ ํฌ๊ธฐ๋ byte๋จ์์ด๋ค.
free : ํ ๋นํ๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํด์ ํ๋ค.
* ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋นํ๊ธฐ
malloc ํจ์๋ฅผ ์ด์ฉํ์ฌ, ์ํ๋ ์์ ์ ์ํ๋ size๋งํผ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ธฐ ๋๋ฌธ์, ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์ด๋ผ๊ณ ํ๋ค.(dynamic memory allocation)
#include <stdio.h>
#include <stdlib.h>
int main(){
int *pointer ; // ํฌ์ธํฐ ์ ์ธ
pointer = malloc(sizeof(int)); // int์ ์ฌ์ด์ฆ๋งํผ ๋ฉ๋ชจ๋ฆฌ ํ ๋น. (4byte)
printf("%p", pointer); // ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์ ์ถ๋ ฅ.
free(pointer); // ๋ฉ๋ชจ๋ฆฌ ํ ๋น ํด์
}
ํฌ์ธํฐ = malloc(size); ํ์์ผ๋ก ํ ๋นํ๋ฉด ๋๋ค.
* ์คํ(stack)๊ณผ ํ(heap)
malloc์ ์ด์ฉํ์ฌ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ฉด , ํ ์์ญ์ ๊ณต๊ฐ์ ์ก๋๋ค. ํ์ ์ ์ฅ๋๋ ๊ฒฝ์ฐ๋ ๋ฐ๋์ ๋ฉ๋ชจ๋ฆฌ ํด์ ๋ฅผ ํด์ค์ผํ๋ค. (freeํจ์๋ฅผ ์ด์ฉํ์ฌ)
์ผ๋ฐ๋ณ์๋ฅผ ์ด์ฉํ๋ค๋ฉด, ์คํ์ ๊ณต๊ฐ์ ์ฐจ์งํ๋ฉฐ, ๋ฐ๋ก ํด์ ๋ฅผ ํด์ฃผ์ง ์์๋๋๋ค.
* memset ํจ์
memset (memory set)ํจ์๋ ์ํ๋ ํฌ๊ธฐ๋งํผ , ์ํ๋ ๊ฐ์ผ๋ก ํ๋ฒ์ ์ค์ ํ๋๋ก ๋์์ฃผ๋ ํจ์์ด๋ค.
string.h ํค๋์ ์ ์๋์ด์์ผ๋ฉฐ , memset(ํฌ์ธํฐ, ๋ฃ์ ๊ฐ , size); ํํ๋ก ์ฌ์ฉํ๋ฉด ๋๋ค.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(){
int *pointer1 = malloc(10); // ํฌ์ธํฐ๋ณ์ pointer1 ์ 10 byteํ ๋น
memset(pointer1 , 0 , 10); // (pointer1๊ฐ ๊ฐ๋ฆฌํค๋ ๊ณต๊ฐ์, 0์ผ๋ก ์ฑ์ด๋ค, 10byte๋งํผ)
printf("%d", *pointer1);
free(pointer1);
return 0;
}
์ถ๋ ฅ >>>>>> 0
memset ํจ์๋ malloc ํจ์๋ ํ ๋นํ size์ ์ซ์๋ฅผ ๋ฃ๊ธฐ๋ณด๋ค๋ sizeof(์๋ฃํ)์ ํํ๋ก ์ฌ์ฉํ๋ค.
*๋ ํฌ์ธํฐ (null pointer)
๋ ํฌ์ธํฐ๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ ๋น๋์ง ์์ ํฌ์ธํฐ๋ฅผ ๋งํ๋ค. ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ ๋น๋์ง ์์์ผ๋ฏ๋ก, ๊ฐ๋ฆฌํค๋๊ฒ๋ ์๋ฌด๊ฒ๋ ์๋ค.
๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ๋ ์ญ์ฐธ์กฐ๋ ํ ์์๋ค.
#include <stdio.h>
int main(){
int *pointer1 = NULL;
printf("%p\n", pointer1 );
return 0;
}
์ถ๋ ฅ >>>>>>> 00000000
์ด๋ฌํ ๋ ํฌ์ธํฐ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ธฐ์ ์, ์ด๋ฏธ ๋ฉ๋ชจ๋ฆฌ๊ฐ์ ๊ฐ๊ณ ์๋์ง ํ์ธํ๋ ์ฉ๋๋ก ์ฌ์ฉ๋๋ค.
* ํฌ์ธํฐ์ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฐฐ์ด์ฒ๋ผ ์ฌ์ฉํ๊ธฐ.
ํฌ์ธํฐ์ malloc ํจ์๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ฉด, ๋ฐฐ์ด์ฒ๋ผ ์ธ๋ฑ์ค๋ฅผ ํตํด ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค.
#include <stdio.h>
#include <stdlib.h> // malloc, free ํจ์ ํฌํจ ํค๋ํ์ผ
int main()
{
int *numPtr = malloc(sizeof(int) * 10); // int 10๊ฐ ํฌ๊ธฐ๋งํผ ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
numPtr[0] = 10; // ๋ฐฐ์ด์ฒ๋ผ ์ธ๋ฑ์ค๋ก ์ ๊ทผํ์ฌ ๊ฐ ํ ๋น
printf("%d\n", numPtr[0]); // ๋ฐฐ์ด์ฒ๋ผ ์ธ๋ฑ์ค๋ก ์ ๊ทผํ์ฌ ๊ฐ ์ถ๋ ฅ
free(numPtr); // ๋์ ์ผ๋ก ํ ๋นํ ๋ฉ๋ชจ๋ฆฌ ํด์
return 0;
}
int *numPtr = malloc(sizeof(int)*10);
int numArr[10] ;
์ฆ, ์์ ํฌ์ธํฐ์, ๋ฐฐ์ด์ ๊ฐ์ ์ญํ ์ ์ํ ํ ์ ์๋ค.
1์ฐจ์ ๋ฐฐ์ด ๋ฟ ์๋๋ผ, 2์ฐจ์, 3์ฐจ์ ๋ฐฐ์ด๋ ์ด์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ํฌ์ธํฐ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํํ ์ ์๋ค.
* ํฌ์ธํฐ์ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ 2์ฐจ์ ๋ฐฐ์ด์ฒ๋ผ ์ฌ์ฉํ๊ธฐ.
2์ฐจ์ ๋ฐฐ์ด์ ๋ฐ๋ณต๋ฌธ์ ํตํด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ณ , ๋ค์ ๋ฐ๋ณต๋ฌธ์ ํตํด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํด์ผํ๋ค.
- ์ธ๋ก ๊ณต๊ฐ ๋ฉ๋ชจ๋ฆฌํ ๋น : ์๋ฃํ **ํฌ์ธํฐ์ด๋ฆ = malloc(sizeof(์๋ฃํ *) * ์ธ๋กํฌ๊ธฐ);
- ๊ฐ๋ก ๊ณต๊ฐ ๋ฉ๋ชจ๋ฆฌํ ๋น : (๋ฐ๋ณต๋ฌธ์ ํตํด) ํฌ์ธํฐ[i] = malloc(sizeof(์๋ฃํ) * ๊ฐ๋กํฌ๊ธฐ);
ํฌ์ธํฐ๋ฅผ 2์ฐจ์ ๋ฐฐ์ด์ฒ๋ผ ์ฌ์ฉํ๊ธฐ