C ์ธ์ด์ ํฌ์ธํฐ
์์ง๊น์ง ๋ง์ ์ฌ๋๋ค์๊ฒ C ์ธ์ด๋ ์ฌ๋๋ฐ๊ณ ์๊ณ , ๊ทธ์ ๊ฐ์ฒด์งํฅ์ธ C++ ๋ํ ์ฌ๋๋ฐ๊ณ ์์ผ๋ฉฐ ํ๋ก๊ทธ๋๋ฐ์ ์์ด์ ํ์์ ์ธ Unmanaged Languaged ๋ผ๊ณ ํ๊ฐ๋ฐ๋๋ค.
๊ทธ ์ด์ ๋ ํ๋์ ์ธ์ด ์ค ๊ฐ์ฅ ์ด์ ๋ธ๋ฆฌ์ ๊ทผ์ ํด์๊ฐ ์๋๊น ์ถ์ ์๊ฐ์ด๊ณ ๊ทธ ์ฃผ์ญ์ด ๋ฐ๋ก ํฌ์ธํฐ ์ด๋ค.
๊ทธ๋ผ ํฌ์ธํฐ๋ ๋ฌด์์ผ๊น?
ํฌ์ธํฐ๋ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์๊ฐ์ ์ง์ ํ ์ ์๋ ๋ฌด์ธ๊ฐ ์ฏค์ผ๋ก ์๊ฐํ์
์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๊ฐ ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํด๋ณด์
#include <stdio.h>
int main() {
int number = 100;
return 0;
}
๊ทธ๋ฌ๋ฉด ๋ฉ๋ชจ๋ฆฌ 0x22 ์ฃผ์์ 4 byte ์ ๊ณต๊ฐ์ด ํ ๋น๋๋ค.
๊ทธ๋ฌ๋ฉด ์ฐ๋ฆฌ๋ ํด๋น ์ฃผ์๋ก ์ ๊ทผ์ ํ๊ธฐ ์ํด์๋ number
์ด๋ผ๋ ๋ณ์๋ฅผ ์ง์ ์กฐ์ํด์ผ ํ๋ค.
ํ์ง๋ง ์ฌ๊ธฐ์ ํฌ์ธํฐ๊ฐ ์๋ค๋ฉด ํฌ์ธํฐ ๋ณ์ ๋ง์ผ๋ก ํด๋น ์ฃผ์ ๊ณต๊ฐ์ ์กฐ์ํ ์ ์๊ฒ ๋๋ค.
ํฌ์ธํฐ ๋ณ์
ํฌ์ธํฐ ๋ณ์๋ ๋ง ๊ทธ๋๋ก ํฌ์ธํฐ, ์ฆ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์ ๊ฐ์ ์ ์ฅํ ์ ์๋ ๋ณ์์ด๋ค.
์ฐ๋ฆฌ๊ฐ ์ฃผ์๊ฐ์ ์ ์ฅํ๊ธฐ ์ํด์๋ 2๊ฐ์ง ์ฐ์ฐ์๋ฅผ ์์์ผ ํ๋ค.
- ์ฐธ์กฐ ์ฐ์ฐ์ (
*
) - ์ฃผ์ ์ฐ์ฐ์ (
*
)
์ฐธ์กฐ ์ฐ์ฐ์
์ฐธ์กฐ ์ฐ์ฐ์๋ ํฌ์ธํฐ์ ์ด๋ฆ์ด๋ ์ฃผ์ ์์ ์ฌ์ฉํด์ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์์ ์ง์ ๋ ๊ฐ์ ๋ฐํํ๋ ์ญํ ์ ์ํํ๋ค.
์ฐธ์กฐ์ฐ์ฐ์๋ 2๊ฐ์ง๋ก ์ฌ์ฉ๋ ์ ์๋๋ฐ, ๋ณ์ ์์ฑ ์์ ์ฌ์ฉ๋๋ฉด ํฌ์ธํฐ ๋ณ์๋ฅผ ํ ๋นํ๋ค๋ ๊ฒ์ด๊ณ ์ผ๋ฐ ์ฐ์ฐ์ ์ฌ์ฉ๋๋ฉด ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ๋ฐํ ํ๋ ์ญํ ์ ํ๋ค.
- ์ฐธ์กฐ ์ฐ์ฐ์์ ์ฌ์ฉ ์์น
- ๋ณ์ ์์ฑ ์
- ํฌ์ธํฐ ๋ณ์ ์์ฑ
- ์ผ๋ฐ ์ฐ์ฐ ์
- ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ๋ฐํ
- ๋ณ์ ์์ฑ ์
ํฌ์ธํฐ ๋ณ์๋ฅผ ์ ์ธํ๊ธฐ ์ํด์๋ *
์ด๋ผ๋ ์ฐธ์กฐ ์ฐ์ฐ์๋ฅผ ์ด์ฉํ๋ฉฐ ์ผ๋ฐ ๋ณ์์ ๊ฐ์ด ์์ฑํ๋ค.
์ฝ๋๋ก ๋ณด์๋ฉด
#include <stdio.h>
int main() {
int number = 100;
int *pointer; // ๋ณ์ ์์ฑ ์์ ์ฌ์ฉ๋์์ผ๋ ํฌ์ธํฐ ๋ณ์ ํ ๋น
printf("%d", *pointer); // ์ผ๋ฐ ๋ผ์ธ์์ ์ฌ์ฉ๋์์ผ๋ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฐ์ดํฐ ๊ฐ์ ๋ฐํ
return 0;
}
๊ทธ๋ผ number
๋ผ๋ ๋ณ์๊ฐ ์กด์ฌํ๋ ์ฃผ์๋ฅผ ์ด๋ป๊ฒ pointer
๋ณ์์ ํ ๋นํ ๊น?
์ฃผ์ ์ฐ์ฐ์
์ฃผ์ ์ฐ์ฐ์๋ ๋ณ์์ ์ด๋ฆ ์์์ ์ใ ๋๋ฉฐ ํด๋น ๋ณ์์ ์ฃผ์๊ฐ์ ๋ฐํํ๋ ์ญํ ์ ์ํํ๋ค.
๋ฐ๋ก &
์ฐ์ฐ์๋ฅผ ์ด์ฉํ๋ฉด ๋๋ค.
๊ทธ๋ผ ์ฐ๋ฆฌ๋ number ๋ผ๋ ๋ณ์์ ์ฃผ์๋ฅผ pointer ๋ผ๋ ๋ณ์์ ํ ๋นํ ๊ฒ์ด๋ฏ๋ก ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ฅผ ๋ง๋ค์ด๋ผ ์ ์๋ค.
#include <stdio.h>
int main() {
int number = 100;
int *pointer = &number;
return 0;
}
๊ทธ๋ผ ๊ฒฐ๊ตญ pointer
๋ผ๋ ํฌ์ธํฐ ๋ณ์์ number
์ ์ฃผ์ ๊ฐ์ด ํ ๋น๋์ด ๋ค์๊ณผ ๊ฐ์ ์ํฉ์ด ๋๋ค.
๊ทธ๋ผ ๋ค์๊ณผ ๊ฐ์ ์ฐ์ฐ์ด ๊ฐ๋ฅํด ์ง ๊ฒ์ด๋ค.
#include <stdio.h>
#include <assert.h>
int main() {
int number = 16;
int *pointer = &number; // number ๋ณ์์ ์ฃผ์๊ฐ ์ ์ฅ
assert(&number == pointer);
assert(number == *pointer);
assert(&number !== &pointer);
printf("ํ
์คํธ ์ฑ๊ณต");
return 0;
}
์ ๋ฆฌํ์๋ฉด
ํฌ์ธํฐ ๋ณ์๋ ๊ผญ ์ฃผ์๊ฐ์ด ํ ๋น๋์ด์ผ ํ๋ค.
์ฃผ์ ๊ฐ์ ํ ๋นํ๊ธฐ ์ํด์๋ ์ฃผ์ ์ฐ์ฐ์๋ฅผ ํตํด์ ํน์ ๋ณ์์ ์ฃผ์ ๊ฐ์ ๋ฐํ๋ฐ์ ํฌ์ธํฐ ๋ณ์์ ํ ๋นํด์ผ ํ๋ค.
ํฌ์ธํฐ๋?
- ๋ฒ์ง์ ๋ํ ๊ธฐํธํ๋ ํํ
- ํฌ์ธํฐ == ์ฃผ์๊ฐ
ํฌ์ธํฐ ๋ณ์๋?
- ํฌ์ธํฐ == ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์๊ฐ
- ํฌ์ธํฐ ๋ณ์ == ํฌ์ธํฐ๋ฅผ ์ ์ฅํ๋ ๋ณ์
- ์ฃผ์ ๊ฐ์ด ๋ค์ด๊ฐ๋ ๋ณ์
ํฌ์ธํฐ ๋ณ์ ์ ์
int *p;
์ ๊ฐ์ ํํ๋ก ์ ์- ์ฆ p๋ int ํ ๋ฐ์ดํฐ ํ์ ์ด ์ ์ฅ๋๋ ์ฃผ์๋ฅผ ์ ์ฅํ ์ ์๋ ๋ณ์์
&
์ฐ์ฐ์
- ํฌ์ธํฐ ๋ณ์์ ๊ฐ์ ํ ๋นํ๊ธฐ ์ํด์๋ ์ค๋ก์ง ์ฃผ์ ๊ฐ๋ง ๊ฐ๋ฅ
&
์ฐ์ฐ์๋ ๋ฐ์ดํฐ์ ์ฃผ์๋ฅผ ํ์ธํ๊ธฐ ์ํด์ ์ฌ์ฉ๋จ- ์ด๋ค ๋ณ์๊ฐ ์ ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ ์ ๋ ๋ฒ์ง
*
์ฐ์ฐ์์ &
์ฐ์ฐ์์ ๊ด๊ณ
&
ํน์ ํ ๋ณ์์ ์ ๋ ๋ฒ์ง*
์ฐ์ฐ์๋ ํฌ์ธํฐ ๋ณ์์ ์ ์ฅ๋ ์ ๋ ๋ฒ์ง๋ฅผ ์ฐธ์กฐํด ์ ์ฅ๋ ๊ฐ
*
์ ์ฌ์ฉ ์์น์ ๋ฐ๋ฅธ ์ญํ
- ์ ์๋ ๋ ์ฌ์ฉ
- ์ฐธ์กฐ ์ฐ์ฐ์
- ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅํ ์ ์๋ ๋ณ์ ํ ๋น
- ์์์์ ์ฌ์ฉ
- ์ญ์ฐธ์กฐ ์ฐ์ฐ์
- ๋ณ์์ ๋ํ ์ญ์ฐธ์กฐ
- dereferencing
๋๊ธ