2์ฐจ์ ๋ฐฐ์ด์ ํํ
์ฐ๋ฆฌ๊ฐ 2์ฐจ์ ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ์ ๋ํ ์๊ด๊ด๊ณ๋ฅผ ํ์ ํ๊ณ ์กฐ์ํ๊ธฐ ์ํด์๋ 2์ฐจ์ ๋ฐฐ์ด์ด ๋ฉ๋ชจ๋ฆฌ์ ์ด๋ป๊ฒ ์ ์ฅ๋๋์ง ์์์ผ ํ๋ค.
๋ค์๊ณผ ๊ฐ์ ๋ฐฐ์ด์ด ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํด๋ณด์.
int arr[3][2] = {
{11, 22},
{33, 44},
{55, 66},
};
๊ทธ๋ผ ๋ฉ๋ชจ๋ฆฌ์ ๋ค์๊ณผ ๊ฐ์ด ์ ์ฅ๋ ๊ฒ์ด๋ผ๋ ๊ทธ๋ฆผ์ ๋ง์ด ๋ด ์๋ค
ํ์ง๋ง ์ ํ์ด ๋ง ํ๋ค๋ฉด, ์ด ๊ทธ๋ฆผ์ ์กฐ๊ธ ์ด์ํ๋ค.
2์ฐจ์ ๋ฐฐ์ด์ด๋ผ ์ฐ๋ฆฌ๊ฐ ๋ณด๊ธฐ ์ฝ๊ฒ ๊ตฌ๋ถํด๋์ ๊ฒ์ผ ๋ฟ์ด์ง ์ ๋ ๊ฒ 2์ฐจ์์ผ๋ก ์ ์ฅ๋์ง ์๋๋ค.
๋ฉ๋ชจ๋ฆฌ๋ ์ฐ์์ ์ธ ํน์ฑ ๋๋ถ์ 1์ฐจ์์ผ๋ก ๋ณด๋ ๊ฒ์ด ๋ ์ฌ๋ฐ๋ฅด๋ค
๊ทธ๋ผ ๋ ์ฌ๋ฐ๋ฅธ ๊ตฌ์กฐ๋ฅผ ๊ทธ๋ ค๋ณด์๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
์ด๋ ๊ฒ ๋จผ์ ๋จธ๋ฆฌ์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ์ดํดํ๊ณ ์์ด์ผ ํฌ์ธํฐ์ 2์ฐจ์ ๋ฐฐ์ด์ ์๊ด๊ด๊ณ์ ๋ํด์ ์ ์ ์๋ค.
2์ฐจ์ ๋ฐฐ์ด์ ์ฐ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋๋ค๊ณ ํด์ 1์ฐจ์ ๋ฐฐ์ด์ฒ๋ผ ์ผ์ด๋ก ๋ณด์ฌ์คฌ์ง๋ง ์๋์ ๋์ฌ ๊ทธ๋ฆผ์ ๊ฐ๋ ์ฑ์ ์ํด์ 2์ฐจ์ ๊ตฌ์กฐ๋ก ๋ฉ๋ชจ๋ฆฌ์ ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํด๋ณด์.
2์ฐจ์ ๋ฐฐ์ด์ ํฌ์ธํฐ
ํฌ์ธํฐ ๋ณ์์ 2์ฐจ์ ๋ฐฐ์ด์ ํ ๋นํ๊ธฐ ์ํด์๋ int (*pointer)[ํ์ ์];
ํํ๋ก ์ ์ํด์ผ ํ๋ค.
๋ฐ๋ก ์ฝ๋๋ก ํ์ธํด๋ณด์
#include <stdio.h>
int main() {
int arr[3][2] = {
{11, 22},
{33, 44},
{55, 66},
};
int (*pointer)[2]; // ํ์ 2๋ก ํ๋ 2์ฐจ์ ๋ฐฐ์ด ํฌ์ธํฐ ํ๋ ์์ฑ
pointer = arr;
return 0;
}
์ฌ๊ธฐ์ ๊ดํธ์ ์ญํ ์ด ๋ง์ด ์ค์ํ๋ค.
๋ง์ฝ ๊ดํธ๋ฅผ ์๋ตํ๊ณ *pointer[2]
๋ผ๊ณ ํ๋ฉด ์ด๋ ํฌ์ธํฐ ๋ฐฐ์ด์ ์์ฑํ๊ฒ ๋ค๋ ๋ป์ผ๋ก, int ํ ํฌ์ธํฐ 2๊ฐ๊ฐ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋๋ ๋ฐฐ์ด์ด ์์ฑ๋๊ฒ ๋๋ค.
1์ฐจ์ ๋ฐฐ์ด๋ก ์๊ฐํ๊ธฐ
2์ฐจ์ ๋ฐฐ์ด์ ํฌ์ธํฐ๋ก ๋ค๋ฃจ๊ธฐ ์ํด์ ์ฐ์ 1์ฐจ์ ๋ฐฐ์ด์ด ์ฐ์์ ์ผ๋ก ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํด๋ณด์
๊ทธ๋ผ ์์ ์ฝ๋์์๋ ๋ฐฐ์ด size ๊ฐ 2์ธ ๋ฐฐ์ด 3๊ฐ๊ฐ ์ฐ์์ ์ผ๋ก ์กด์ฌํ๋ค๊ณ ์ดํดํ ์ ์๋ค.
๊ทธ๋ผ 2์ฐจ์ ๋ฐฐ์ด์์๋ ์ญ์ 1์ฐจ์ ๋ฐฐ์ด์ ๊ฐ๋ ์ ํจ๊ป ์ด์ฉํ ์ ์๋ค.
2์ฐจ์ ๋ฐฐ์ด ํฌ์ธํฐ๋ก ๋ฐฐ์ด ์ฃผ์ ์ ๊ทผํ๊ธฐ
๊ฒฐ๊ตญ ํฌ์ธํฐ๋ฅผ ์ด์ฉํด์ ์ด๋ค ๊ฐ๊ฐ์ ์ฃผ์๋ก ์ ๊ทผํ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ ์ ์๋ค
arr[0]
:*pointer
- pointer ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์
arr[1]
:*(pointer + 1)
- pointer ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์ + 4 byte
arr[2]
:*(pointer + 2)
- pointer ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์ + 8 byte
๊ทธ๋ผ ์ด ํน์ฑ์ ์ด์ฉํด์ ๋ฐฐ์ด์ ๋ชจ๋ ์์์ ์ฃผ์์ ์ ๊ทผํ ์ ์๋ค.
์ด๋ ๊ฒ ํฌ์ธํฐ์ ์ ์๋ฅผ ์ด์ฉํด์ byte ๋ฅผ ์ฎ๊ฒจ ๋ชจ๋ ์์์ ์ ๊ทผํ ์ ์๊ฒ ๋๋๋ฐ, ์ด๊ฒ ์กฐ๊ธ ํท๊ฐ๋ฆด ์ ์๋ค.
arr[1][1] == *(pointer + 1) + 1
์ ์ข ๋ ๋ถ์ํด๋ณด์
์ด๋ pointer ๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์ (arr)์ 4 byte ๋ฅผ ๋ํ๊ณ +1 ๋ก ์ธํด ๋ 4byte ๋ฅผ ๋ํ ์ฃผ์๊ฐ์ด ๋๋ ๊ฒ์ด๋ค.
์ด๋ฅผ ๋ฐ์ฆ๋ฌธ์ ํตํด์ ์ฆ๋ช ํด๋ณด์๋ฉด,
#include <assert.h>
int main() {
int arr[3][2] = {
{11, 22},
{33, 44},
{55, 66},
};
int (*pointer)[2] = arr;
assert(&arr[0][0] == *pointer);
assert(&arr[0][1] == *pointer + 1);
assert(&arr[1][0] == *(pointer + 1));
assert(&arr[1][1] == *(pointer + 1) + 1);
assert(&arr[2][0] == *(pointer + 2));
assert(&arr[2][1] == *(pointer + 2) + 1);
return 0;
}
2์ฐจ์ ๋ฐฐ์ด ํฌ์ธํฐ๋ก ๋ฐฐ์ด ์์์ ๊ฐ ๊ฐ์ ธ์ค๊ธฐ
์ด์ ๋ชจ๋ ์์์ ์ฃผ์์ ์ ๊ทผํ ์ ์๊ฒ ๋์๋ค! ๊ทธ๋ผ ์ฐธ์กฐ ์ฐ์ฐ์ ์ด์ฉํด์ ์ค์ ๊ฐ์ ์ทจํ ์ ์๊ฒ ๋๋ค.
#include <stdio.h>
int main() {
int arr[3][2] = {
{11, 22},
{33, 44},
{55, 66},
};
int (*pointer)[2] = arr;
printf("%d\n", **pointer);
printf("%d\n", *(*pointer + 1));
printf("%d\n", *(*(pointer + 1) + 0)); // + 0 ์ ์๋ต ๊ฐ๋ฅ
printf("%d\n", *(*(pointer + 1) + 1));
printf("%d\n", *(*(pointer + 2) + 0)); // + 0 ์ ์๋ต ๊ฐ๋ฅ
printf("%d\n", *(*(pointer + 2) + 1));
return 0;
}
'๐คท๐ผโโ๏ธ Etc... > - C, C++, Python, Android' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C ์ธ์ด] struct, ๊ตฌ์กฐ์ฒด์ ๊ธฐ๋ณธ๊ณผ ์ฌ์ฉ ๋ฐฉ๋ฒ (0) | 2021.07.04 |
---|---|
[C ์ธ์ด] malloc ๊ณผ free ๋ก ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌํ๊ธฐ (0) | 2021.07.04 |
[C ์ธ์ด] ํฌ์ธํฐ๋ก 1์ฐจ์ ๋ฐฐ์ด ๋ค๋ฃจ๊ธฐ (์ฃผ์ ์ ๊ทผ ๋ฐ ์์ ๊ฐ ์ ๊ทผ) (1) | 2021.07.03 |
[C ์ธ์ด] ํฌ์ธํฐ์ ํฌ์ธํฐ๋ฅผ ์ํ ์ฌ๋ฌ ์ฐ์ฐ์ (0) | 2021.07.02 |
[C ์ธ์ด] 1์ฐจ์ ๋ฐฐ์ด์ ๊ธฐ์ด (0) | 2021.06.23 |
๋๊ธ