[C] ํฌ์ธํฐ๋?
C์ธ์ด ํ์ต์๋ค์ ๊ฐ๋ก๋ง๊ณ ์๋ ๊ฐ์ฅ ํฐ ์ฅ๋ฒฝ์ ์๋ง ํฌ์ธํฐ์ผ ๊ฒ์ด๋ค.
์ฌ์ค ๋๋ ๊ทธ๋ ๊ฒ ์ด๋ ต๋ค๊ณ ๋๊ปด๋ณธ ์ ์ ์๋๋ฐ... ๊ทธ๋ ๋ค๋ฉด ๊ทธ๋ฐ๊ฑฐ๊ฒ ์ง
์ ๋ง ์ดํด๋ง ํ๋ฉด ๋ณ๊ฑฐ์๋ ๊ฐ๋ ์ด๋ค.
๋ณ์๊ฐ ๋ฌด์์ธ์ง ๊ธฐ์ตํ๋๊ฐ?
๋ณ์๋ฅผ ์์ฑํ๋ค๋ ๊ฒ์ ํน์ ๋ฉ๋ชจ๋ฆฌ๊ณต๊ฐ์ ์ด๋ฆ์ ๋ถ์ฌ์ค๋ค๋ ๋ป์ด๋ค.
๊ทธ๋ฆฌ๊ณ ํฌ์ธํฐ๋ ๊ทธ ํน์ ๋ฉ๋ชจ๋ฆฌ๊ณต๊ฐ์ ์ง์ง ์ด๋ฆ์ ๊ฐ๋ฆฌํค๋ ๊ฐ์ด๋ค.
๋น์ ํ์๋ฉด ๋ณ์๋ ๋ณ๋ช ์ด๊ณ , ํฌ์ธํฐ๋ ๋ณธ๋ช ์ด๋ผ๊ณ ํ ์ ์๊ฒ ๋ค.
๋ณ๋ช ์ ๋ถ๋ฅด๊ธฐ์ ๋ฐ๋ผ์ ์์ญ์๋ฐฑ๊ฐ๋ ๋ ์ ์์ง๋ง ๋ณธ๋ช ์ ํ๋ ๋ฟ์ด๋ค.(๊ทํ๋ฅผ ํ์ง ์์๋ค๋ฉด)
๊ทธ๋์ ์ด๊ฑธ ๋๋์ฒด ์ด๋ป๊ฒ ์ด๋ค๋ ๊ฑด๊ฐ?
์ด์ ๋ฐฉ๋ฒ๋ก ์ ์ธ ์ธก๋ฉด์ผ๋ก ๋ด๋ณด์.
์ผ๋จ ํฌ์ธํฐ ๋ณ์๋ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉํ ์ ์๋ค.
int num=20;
int* ptr=#
printf("%d",*ptr);
//output->20
int* ๋ "int ํ์
์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ ํ์
" ์ด๋ผ๊ณ ์ดํดํ ์ ์๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก char*, short*... ๋ญ๋ *๋ฅผ ๊ฐ๋ค๋ถ์ด๋ฉด ๊ทธ ํ์
์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ ํ์
์ด ๋๋ค.
๊ทธ๋์ int* ํ์ ์ ๋ณ์ ptr๊ฐ ์์ฑ๋๋ค.
๊ทธ๋ฆฌ๊ณ ptr๋ ๋ณ์๋๊น ๊ฐ์ ๋ฃ์ ์ ์๋ค!
10์ด๋ 50๊ฐ์ ๊ทธ๋ฅ ์ซ์๋ ๋ฃ์ ์ ์๊ธด ์๋๋ฐ, ๊ทธ๋๋ด์ผ ์ฐ์ง๋ ๋ชปํ๋ ์ฐ๋ ๊ธฐ๊ฐ ๋ ๋ฟ์ด๋ค.
ํฌ์ธํฐ ๋ณ์๋๊น ๋น์ฐํ ๊ทธ์ ๋ง๋ ํฌ์ธํฐ ๊ฐ(์ดํ ์ฃผ์๊ฐ)์ ๋ฃ์ด์ค์ผ ํ๋ค.
๊ทธ๋์ ๋ฑ์ฅํ๋ ๋ถ๋ถ์ด ๋ฐ๋ก &num์ด๋ค.
num ๋ณ์์ ์ฃผ์๊ฐ์ ๋ฐํํ๋ค๋ ์๋ฏธ์ด๊ณ , ์ด๊ฒ์ด ptr์ ๋์
๋จ์ผ๋ก์จ ptr์ ์ง์ ํ ํฌ์ธํฐ์ ์ญํ ์ ํ ์๊ฐ ์๊ฒ ๋๋ค...
์ด์ ptr์ num์ ๋ณธ๋ช
(์ฃผ์๊ฐ)์ ๊ฐ๊ณ ์๋ค.
์ด ๋ณธ๋ช
์ ๊ตณ์ด ์๊ณ ์ถ๋ค๋ฉด
printf("%p",ptr); ์ด๋ ๊ฒ ์ฐ๋ฉด ๋๋ค. ์ซ์์ ์ํ๋ฒณ์ผ๋ก ์ผ๋ฃฉ์ง 16์ง์ ์ซ์๊ฐ ๋์ฌ ๊ฒ์ด๋ค...
๊ทธ๋ฆฌ๊ณ *ptr; ์ด๋ผ๋ ์ฐ์ฐ์ ํํด๋ณด์.
์ฌ๊ธฐ์์์ ์ ๊ณฑ์
๋ ์๋๊ณ , int ํ์
์์์ *๋ ์๋ ๋ณ๊ฐ์ ์ฐ์ฐ์ด๋ค. ๊ทธ๋ฅ ๊ธฐํธ๋ง ๊ฐ๋ค.
์ ๊ตฌ์ ์ ํด์ํ์๋ฉด "ptr์ ๋ด๊ธด ๋ณธ๋ช (์ฃผ์๊ฐ)์ ๋ฐ๋ผ๊ฐ์ ๊ฑฐ๊ธฐ์ ์ ์ฅ๋ ๊ฐ์ ์ ๊ทผํ๊ฒ ๋ค"
๋ผ๋ ์๋ฏธ๊ฐ ๋๋ค.
๊ทธ๋ฆฌ๊ณ
*ptr=40;
์ด๋ฐ์์ผ๋ก ์ ๊ทผํด์ ๋ฃ์ด์ฃผ๋ฉด
๋ณธ๋ช ์ ํตํด์ ๋ณธ์ง์ ์ธ ์ ๊ทผ์ ํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ๋น์ฐํ num์ ๊ฐ๋ 40์ด ๋๋ค. (num์ ๋ณ๋ช ์ผ ๋ฟ์ด๋ค.)
๊ทธ๋ฆฌ๊ณ ํน์ ๊ตฌ๊ฐ์ ๋ก์ปฌ ๊ฐ์ ์ธ๋ถ์์ ์ปจํธ๋กคํ ์ ์๋๋ก ๋๊ฒจ์ค ์๋ ์๋ค.
int ํ์ ๋ณ์ num์ ํจ์์ ๋๊ฒจ์ ํ๋ ์ฆ๊ฐ์ํค๋ ์ฝ๋๋ฅผ ์ง๋ณด์.
void AddOne(int add)
{
ใ
คadd++;
}
int main()
{
ย ใ
คint num=10;
ใ
คAddOne(num);
ใ
คprintf("%d",num);
}
์ ์ปดํ์ผ์ ํด๋ณด์.
๋ฌด์จ ๊ฐ์ด ๋์ฌ๊น?
์ฐ๋ฆฌ๊ฐ ๊ธฐ๋ํ๋ ๊ฐ์ 11์ธ๋ฐ
๊ฒฐ๊ณผ๋ 10์ด๋ค.
์ ๊ทธ๋ด๊น?
๋งค๊ฐ๋ณ์๋ก์ ๊ฐ ์ ๋ฌ์ ์ค๋ก์ง '๊ฐ' ์ ๋ฌ๋ง ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ด๋ค.
num์ ๋ด๊ธด ๊ฐ์ 10์ด๊ณ , AddOne ํจ์์ ์ธ์๋ก๋ 10์ด ์ ๋ฌ๋๋ค. num์ด ์๋๋ผ.
AddOne ์์์ ๊ทธ๋ฅ ์์ 10์ ๊ฐ์ ธ๋ค๊ฐ add ๋ณ์์ ๊ฐ์ ๋์ ํด๋ฃ๋๋ฐ,
๊ทธ๊ฑธ 0์ผ๋ก ๋ง๋ค๋ 35๋ก ๋ง๋ค๋ num๊ณผ ๋๋์ฒด ๋ฌด์จ ์๊ด์ด๊ฒ ๋๊ฐ?
์ด๋ด ๊ฒฝ์ฐ์ ํฌ์ธํฐ๊ฐ ์ฌ์ฉ๋๋ค.
ํฌ์ธํฐ๋ฅผ ์ ์ฉํด์ ๊ณ ์ณ๋ณด์.
void AddOne(int* add)
{
ใ
ค*add++;
}
int main()
{
ย ใ
คint num=10;
ใ
คAddOne(&num);
ใ
คprintf("%d",num);
}
๋๋ค. ์ด์ ์ ์์ ์ผ๋ก 11์ด ์ถ๋ ฅ๋๋ค.
AddOne์ num์ ์ฃผ์๋ฅผ ์ ๋ฌํ๊ณ ,
AddOne ์์์๋ ๊ทธ ์ฃผ์๋ฅผ ๋ฐ๋ผ์ num์ ๋ณธ์ฒด์ ์ ๊ทผํ๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ๋ ํ๋์ ์ฉ๋๊ฐ ์๋ค.
int๋ double๊ฐ์ ๊ฑด ๋ญ 4๋ฐ์ดํธ 8๋ฐ์ดํธ๋ฐ์ ์๋๋๊น ๋ค๋ฅธ ํจ์์ ์ ๋ฌํ ๋ ๊ทธ๋ฅ ๊ทธ๋๋ก ์ ํด์ฃผ๋ฉด ๋๋ค.
๊ทธ๋ฐ๋ฐ ๊ตฌ์กฐ์ฒด๊ฐ์ ๊ฒฝ์ฐ๋ผ๋ฉด ์ด๋จ๊น?
์ด๋ฐ์ ๋ฐ ์ ๋ณด๋ค์ด ๋ง์ด ๋ค์ด๊ฐ๋ค๋ณด๋ฉด ์์ญ๋ฐ์ดํธ๋ฅผ ์ฐจ์งํ ์๋ ์๊ณ , ๋ณต์ฌ ์๊ฐ๋ ๋ ์ก์๋จน๊ฒ ๋๋ค.
ํฌ์ธํฐ์ ํฌ๊ธฐ๋ ๋ณดํต 4๋ฐ์ดํธ์ด๊ธฐ ๋๋ฌธ์ ๊ตฌ์กฐ์ฒด ๋์ ๊ตฌ์กฐ์ฒด์ ํฌ์ธํฐ๋ฅผ ์ ๋ฌํ๋ฉด ํจ์จ์ ํฅ์์ํฌ ์ ์๋ค.
๊ทธ๋ฆฌ๊ณ ํฌ์ธํฐ ์ค์์๋ ์ด์ง์ ์ธ ํฌ์ธํฐ๊ฐ ์๋ค.
๋ฐ๋ก void* ํ์ ์ด๋ค.
์ด ํ์ ์ ์ด๋ค ํฌ์ธํฐ ํ์ ์ด๋ ๋ค ์ ์ฅํ ์ ์๋ค.
๊ทธ๋์ ์ฐธ์กฐ ์ ๊ทผ { ex)*ptr } ์ด ๋ถ๊ฐ๋ฅํ๋ค.
๊ทธ๋๋ ๋ญ (int)ptr ์ด๋ฐ์์ผ๋ก ํธ๋ฒ์ ์ฐ๋ฉด ๋๊ณ , ๋ณดํต ํฌ์ธํฐ ํ์ ์ ํ์ ํ ์ ์์ ๋ ์ด๋ค.
์๋ก, ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋์ ํ ๋นํด์ฃผ๋ alloc ๊ณ์ด ํจ์(malloc, calloc...)๋ค์ ๋ชจ๋ void๋ก ๊ฐ์ ๋ฐํํ๋ค. ๊ทธ๋์ int ptr=(int*)malloc(sizeof(int)); ๊ฐ์ ์์ผ๋ก ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
alloc์ ๋ฃ์ ํ์
์ด ๋ญ์ค์๊ณ int*, char*๊ฐ์๊ฑธ ๋ฐํํ๊ฒ ๋๊ฐ...
ํฌ์ธํฐ์ ๋ํ ์ค๋ช ์ ์ด๊ฒ ๋ค๋ค.
๋ณ๊ฑฐ ์๋ค.