๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค๋ ์๋ฃํ์ผ๋ก C์ธ์ด์์๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ก ๊ฐ ๋ณ์๋ฅผ ๊ตฌ๋ณํ๋ค.
์ฐ๋ฆฌ๊ฐ ๋ณดํต ์ฌ์ฉํ๋ ๋ณ์๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ์ง๋ง, ํฌ์ธํฐ๋ ์ฃผ์(๋ฉ๋ชจ๋ฆฌ ์์น)๋ฅผ ์ ์ฅํ๋ค๋ ์ฐจ์ด๊ฐ ์๋ค.
์ฆ, ํฌ์ธํฐ ๋ณ์๋ "์ด๋์ ์ ์ฅ๋ผ ์๋์ง๋ฅผ ๊ธฐ์ต"ํ๋ ๋
์์ด๋ค!
๋ฐ์ดํฐ์ ์ฃผ์๊ฐ์ด๋ ํด๋น ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ์ ์์ ์ฃผ์๋ฅผ ์๋ฏธํ๋ค.
C์ธ์ด์์๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ 1๋ฐ์ดํธ ๋จ์๋ก ๋๋์ด ๊ด๋ฆฌํ๋ฉฐ,
๋ณ์ ํ๋๊ฐ ์ฌ๋ฌ ๋ฐ์ดํธ๋ฅผ ์ฐจ์งํ๋๋ผ๋, "๊ฐ์ฅ ์ฒซ ๋ฒ์งธ ๋ฐ์ดํธ์ ์ฃผ์"๋ง์ ๋ณ์์ ์ฃผ์๋ก ์ฌ์ฉํ๋ค.
#include <stdio.h>
int main() {
int a = 1234;
printf("๋ณ์ a์ ์ฃผ์: %p\n", &a);
return 0;
}
๋ง์ฝ intํ์ด 4๋ฐ์ดํธ๋ผ๋ฉด,
a๋ ์๋ฅผ ๋ค์ด ์๋์ฒ๋ผ 4์นธ์ ์ฐจ์งํ๋๋ผ๋:
๋ฉ๋ชจ๋ฆฌ ์ฃผ์ : 0x100 0x101 0x102 0x103
๋ด์ฉ (a ์ ์ฅ) : ?? ?? ?? ??
&a๋ ํญ์ ๊ฐ์ฅ ์ฒซ ์ฃผ์์ธ 0x100 ๋ง์ ๊ฐ๋ฆฌํจ๋ค!
๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ ์์ (int a = 1234)
โโโโโโโโโโโโโโโโโ
โ ์ฃผ์: 0x100 โ โโโโ &a
โ ๊ฐ: 0xD2 โ
โโโโโโโโโโโโโโโโโค
โ ์ฃผ์: 0x101 โ
โ ๊ฐ: 0x04 โ
โโโโโโโโโโโโโโโโโค
โ ์ฃผ์: 0x102 โ
โ ๊ฐ: 0x00 โ
โโโโโโโโโโโโโโโโโค
โ ์ฃผ์: 0x103 โ
โ ๊ฐ: 0x00 โ
โโโโโโโโโโโโโโโโโ
์ฐธ๊ณ ๋ก ์ ์์๋ Little Endian ๋ฐฉ์์ผ ๋์ ๋ฐ์ดํธ ์ ์ฅ ๋ชจ์ต์ด๋ค.
(C์ธ์ด๋ ๋ณดํต Little Endian ์์คํ ์์ ๋์๊ฐ)
| ํญ๋ชฉ | ์ผ๋ฐ ๋ณ์ (์: int a = 10;) | ํฌ์ธํฐ ๋ณ์ (์: int *p = &a;) |
|---|---|---|
| โญ๏ธ ์๋ฏธ | ์ ์ํ ๊ฐ์ ์ ์ฅํ๋ ๋ณ์ | ์ ์ํ ๋ณ์์ ์ฃผ์๋ฅผ ์ ์ฅํ๋ ๋ณ์ |
| ์ ์ธ ๋ฐฉ์ | int a; | int *p; |
| ์ฌ์ฉ ์ | a = 10; | p = &a; |
| โญ๏ธ ๊ฐ | 10 | a์ ์ฃผ์ (์: 0x7ffe...) |
| ์ญ์ฐธ์กฐ | ์ฌ์ฉํ์ง ์์ | *p๋ฅผ ์ฌ์ฉํด ์ฃผ์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ์ ๊ทผ |
#include <stdio.h>
int main() {
int a = 10;
int *p = &a;
printf("a์ ๊ฐ: %d\n", a);
printf("*p์ ๊ฐ: %d\n", *p);
printf("a์ ์ฃผ์: %p\n", &a);
printf("p์ ์ ์ฅ๋ ์ฃผ์: %p\n", p);
return 0;
}
a์ ๊ฐ: 10
*p์ ๊ฐ: 10
a์ ์ฃผ์: 0x7ffee70b54ac
p์ ์ ์ฅ๋ ์ฃผ์: 0x7ffee70b54ac
#include <stdio.h>
int main() {
int a = 5;
int *p = &a;
*p = 20;
printf("a์ ์๋ก์ด ๊ฐ: %d\n", a);
return 0;
}
a์ ์๋ก์ด ๊ฐ: 20
#include <stdio.h>
int main() {
int arr[3] = {10, 20, 30};
int *p = arr;
for (int i = 0; i < 3; i++) {
printf("arr[%d] = %d, *(p + %d) = %d\n", i, arr[i], i, *(p + i));
}
return 0;
}
arr[0] = 10, (p + 0) = 10
arr[1] = 20, (p + 1) = 20
arr[2] = 30, *(p + 2) = 30
arr[i]์ *(arr + i)๋ ๊ฐ๋ค.arr์ ์ฒซ ๋ฒ์งธ ์์์ ์ฃผ์๋ฅผ ์๋ฏธํ๋ค (int * ํ์).int a = 10;
int *p = &a;
โโโโโโโโโโ โโโโโโโโโโโโโโ
โ a โโโโโโโถ โ 10 โ
โโโโโโโโโโ โโโโโโโโโโโโโโ
โฒ
โ
โโโโโโโโโโ
โ p โโโโโโโโโโโโโโ
โโโโโโโโโโ โ
์ฃผ์ ์ ์ฅ โผ
โโโโโโโโโโโโโโ
โ &a (์ฃผ์)โ
โโโโโโโโโโโโโโ
| ์ค์ ์ฝ๋ | ๋ฌธ์ ์์ธ |
|---|---|
int *p; *p = 10; | ํฌ์ธํฐ ์ด๊ธฐํ ์์ด ์ฌ์ฉ โ segmentation fault |
int *p = NULL; *p = 10; | NULL ์ฃผ์๋ฅผ ์ญ์ฐธ์กฐ โ ํ๋ก๊ทธ๋จ ํฌ๋์ |
int *p; p = &a; | &a์ฒ๋ผ ์ ํจํ ์ฃผ์๋ฅผ ๊ผญ ํ ๋นํด์ผ ํจ |
#include <stdio.h>
void changeValue(int *x) {
*x = 100;
}
int main() {
int a = 10;
changeValue(&a);
printf("๋ณ๊ฒฝ๋ a: %d\n", a);
return 0;
}
#include <stdio.h>
int main() {
int a = 42;
int *p = &a;
int **pp = &p;
printf("a = %d\n", a);
printf("*p = %d\n", *p);
printf("**pp = %d\n", **pp);
return 0;
}
#include <stdio.h>
int main() {
int a = 123;
void *vp = &a;
printf("int ๊ฐ: %d\n", *(int *)vp);
return 0;
}
void *๋ ์ด๋ค ์๋ฃํ์ด๋ ๊ฐ๋ฆฌํฌ ์ ์์ง๋ง, ์ญ์ฐธ์กฐ ์ ์บ์คํ
ํ์!#include <stdio.h>
#include <stdlib.h>
int main() {
int *p = (int *)malloc(sizeof(int) * 5); // intํ 5๊ฐ ๊ณต๊ฐ ํ ๋น
for (int i = 0; i < 5; i++) {
p[i] = i * 10;
printf("p[%d] = %d\n", i, p[i]);
}
free(p); // ๋ฉ๋ชจ๋ฆฌ ํด์
return 0;
}
| ์ํฉ | ํด๊ฒฐ ๋ฐฉ๋ฒ |
|---|---|
| malloc/free ์์ด ๋ง์ง ์์ | ํญ์ free()๋ก ํด์ ํด์ฃผ๊ธฐ |
| free ํ ๋ค์ ์ ๊ทผ | free(p); p = NULL; ์ผ๋ก ์ค์ |
| ๋ฐฐ์ด ํฌ๊ธฐ ๋ณ๊ฒฝ ํ์ | realloc() ์ฌ์ฉ ๊ณ ๋ ค |