๋ฐฐ์ด๊ณผ ํฌ์ธํฐ์ ๊ด๊ณ
ํฌ์ธํฐ์ ๋ฐฐ์ด์ ๋งค์ฐ ๊ธด๋ฐํ ๊ด๊ณ๋ฅผ ๊ฐ๊ณ ์๋ค๊ณ ์ฌ๋ฌ ์์ ๋ฐ ์๋ฃ์์ ์ด์ผ๊ธฐ ํ๋ค.
์ด๋ค ๋ถ๋ถ์์๋ ๋ฐฐ์ด์ด ํฌ์ธํฐ๋ฅผ ๋์ฒดํ๊ธฐ๋ ํ๊ณ ํน์ ํฌ์ธํฐ๊ฐ ๋ฐฐ์ด์ ๋์ฒดํ๊ธฐ๋ ํ๋ค.
๋ฐฐ์ด์ ๋ฐฐ์ธ ๋ ์ฐ๋ฆฌ๋ ๋ค์๊ณผ ๊ฐ์ ๋ด์ฉ์ ์ ์ ์์๋ค.
๋ฐฐ์ด์ ์ด๋ฆ(๋ณ์๋ช )์ ํด๋น ๋ฐฐ์ด์ ์ฃผ์์๊ณผ ๋์์ ์ฒซ ๋ฒ์งธ ์์์ ์ฃผ์ ๊ฐ ์ด๋ค!
์์ ์๊ฐ์ ํฌ์ธํฐ์์๋ ๋ ์ด๋ฐ ๋ด์ฉ์ ์ ์ ์์๋ค.
ํฌ์ธํฐ ๋ณ์์ ์ฌ ์ ์๋ ๊ฐ์ ์ค๋ก์ง ์ฃผ์ ๊ฐ!
๊ทธ๋ผ ๋ค์ ์ฝ๋๊ฐ ๋์ํ ๊น?
#include <assert.h>
int main() {
int arr[] = {11, 22, 33, 44};
int *pointer = arr;
return 0;
}
๊ทธ๋ ๋ค ์์ ์ฝ๋๋ ์ ํ ๋ฌธ์ ๊ฐ ์๋ ์ฝ๋์ด๋ฉฐ ์ ๋์ํ ๊ฒ์ด๋ค.
์๋ง ๋ฉ๋ชจ๋ฆฌ ์ด๋๊ฐ์ ์์ ๊ฐ์ ํํ๋ก ์กด์ฌํ ๊ฒ์ด๋ฉฐ ์ด๊ฒ ๋ฐ๋ก ๋ฐฐ์ด์ ํฌ์ธํฐ ๋ณ์์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ด๋ค.
ํฌ์ธํฐ๋ก ๋ฐฐ์ด ์์ ์ ๊ทผํ๊ธฐ
๋ฐฐ์ด์์ ํน์ ์์์ ์ ๊ทผํ๊ธฐ ์ํด์๋ ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ด ๊ฐ์ฅ ํํ๋ค.
ํ์ง๋ง ํฌ์ธํฐ๋ฅผ ์ด์ฉํ๋ค๋ฉด ํฌ์ธํฐ์ ์ ์๋ฅผ ์ ์ ํ ์กฐ์ํ์ฌ ์ ๊ทผ ํ๋ ๋ฐฉ์๋ ์กด์ฌํ๋ค.
๊ทธ ๋ฐฉ๋ฒ์ ๋ํด์ ์์๋ณด๊ธฐ ์ํด ๋ค์ ์ฝ๋๋ฅผ ์์๋ณด์.
#include <stdio.h>
int main() {
int arr[] = {11, 22, 33, 44};
int *pointer = arr;
printf("%010x", pointer + 0);
printf("%010x", pointer + 1);
printf("%010x", pointer + 2);
printf("%010x", pointer + 3);
return 0;
}
์์ ์ฝ๋์์ pointer + 1
์ด ์๋ฏธํ๋ ๊ฒ์ ๋ฌด์์ผ๊น?
(pointer + ์ ์) ์ ์๋ฏธ
pointer ๋ณ์์ ์ ์๋ฅผ ๋ํ๋ค๋ ๊ฒ์ ํฌ์ธํฐ ๋ณ์์ ๋ฐ์ดํฐ ํ์ ๋งํผ์ byte ๋ฅผ ๋ํ๋ค๋ ์๋ฏธ๊ฐ ๋๋ค.
์ด ๋ง์ ๋ฌด์์ด๋?
์ฆ ๋ค์๊ณผ ๊ฐ๋ค๋ ์๋ฆฌ์ด๋ค.
- pointer + 0
- pointer ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ์ฃผ์ ๊ฐ์ 0byte ๋งํผ์ ๋ํ ์ฃผ์
- pointer + 1
- pointer ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ์ฃผ์ ๊ฐ์ 4byte ๋งํผ์ ๋ํ ์ฃผ์
- pointer + 2
- pointer ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ์ฃผ์ ๊ฐ์ 8byte ๋งํผ์ ๋ํ ์ฃผ์
์ 4 ๋ฐ์ดํธ์ฉ ์ฆ๊ฐํ ๊น?
์ด์ ๋ ๋ฐ๋ก pointer ๋ณ์๊ฐ ํ ๋น๋ ๋ฐ์ดํฐ ํ์ ์ด integer ํ์ ์ด๋ผ ๊ทธ๋ ๋ค.
๊ทธ๋ผ ์์ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ ํํ์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ๊ฐ๊ฒ ๋๋ค
ํฌ์ธํฐ๋ก ์ ๊ทผํ ๋ฐฐ์ด ์์์ ๊ฐ ๊ฐ์ ธ์ค๊ธฐ
์ง๋ ์๊ฐ์ ํฌ์ธํฐ๋ฅผ ์ด์ฉํ ๋ ์ฌ์ฉํ๋ ์ฐธ์กฐ ์ฐ์ฐ์ *
์ ๋ํด์ ์์๋ณด์๋ค.
์ฐธ์กฐ ์ฐ์ฐ์๊ฐ ๋ง์ฝ ๋ณ์๋ช ์์ ์ฌ์ฉ๋๋ค๋ฉด ํด๋น ๋ฉ๋ชจ๋ฆฌ์ ์กด์ฌํ๋ ๊ฐ์ ๋ฐํ ํ๋ค๊ณ ํ์ผ๋ ์ฐ๋ฆฌ๋ ์ฐธ์กฐ ์ฐ์ฐ์๋ฅผ ์ด์ฉํด์ ๋ฐฐ์ด์ ๋ชจ๋ ๊ฐ์ ์ทจํ ์ ์๊ฒ ๋์๋ค.
#include <stdio.h>
int main() {
int arr[] = {11, 22, 33, 44};
int *pointer = arr;
printf("%d", *pointer); // pointer ๊ฐ ๊ฐ๋ฆฌํค๋ arr ์ ์ฃผ์์ ์ฒซ ๋ฒ์งธ ์์์ ๊ฐ์ธ 11 ์ด ์ถ๋ ฅ๋จ
return 0;
}
์ฐ๋ฆฌ๋ ์์์ (pointer + ์ ์) ์ ์๋ฏธ๋ฅผ ์ด์ฉํด์ ๋ชจ๋ ๋ฐฐ์ด ์์์ ๊ฐ์ ์ ๊ทผํ ์ ์๊ฒ ๋๋ค.
์ฃผ์ํ์
์ฐ๋ฆฌ๋ pointer + ์ ์ ๋ฅผ ์ด์ฉํด์ ๋ชจ๋ ๋ฐฐ์ด ์์์ ๊ฐ์ ์ ๊ทผํ ์ ์๋ค๊ณ ํ๋๋ฐ, pointer + ์ ์ ๊ฐ ์ปดํ์ผ๋ฌ์๊ฒ ๋ช ํํ๊ฒ ์ ๋ฌ๋์ง ์์ผ๋ฉด!
์ฆ ๊ดํธ๋ก ์ ์ ํ๊ฒ ๋ฌถ์ง ์์ผ๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.
*pointer + 1
๊ณผ *(pointer + 1)
์ ์์ฃผ ํฐ ์ฐจ์ด๊ฐ ์๋ค๋ ์๋ฆฌ๋ค.
*pointer + 1
- pointer ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์์ ๊ฐ์ ์ ์ 1์ ๋ํ ๊ฐ
*(pointer + 1)
- pointer ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์์์ 4byte ๋งํผ ์ด๋ํ ์ฃผ์์ ์ ์ฅ๋ ๊ฐ
๊ทธ๋์ ์ฐ๋ฆฌ๊ฐ ์์ ๋ฐฐ์ด (pointer + ์ ์)์ ๊ฐ๋
๊ณผ *
์ฐ์ฐ์์ ๊ฐ๋
์ ๋ชจ๋ ์ ์ฉํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ฅผ ์ดํดํ ์ ์๊ฒ ๋๋ค.
#include <assert.h>
int main() {
int arr[] = {11, 22, 33, 44};
int *pointer = arr;
assert(arr[0] == *pointer);
assert(&arr[0] == (pointer + 0));
assert(arr[0] == *(pointer + 0));
assert(&arr[1] == (pointer + 1));
assert(arr[1] == *(pointer + 1));
assert(&arr[2] == (pointer + 2));
assert(arr[2] == *(pointer + 2));
assert(&arr[3] == (pointer + 3));
assert(arr[3] == *(pointer + 3));
return 0;
}
๋๊ธ