๐ก ์ ์
๋ฐฐ์ด์ ์์(๊ฐ ๋๋ ๋ณ์)๋ค์ด ์ฐ์์ ์ผ๋ก ์ ์ฅ๋์ด์๋ ํํ์ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ก, ์ธ๋ฑ์ค ํน์ ํค๋ก ์์๋ฅผ ์ฐธ์กฐํ ์ ์๋ค.
๐ฑ ADT
๋ฐฐ์ด์ ์์(Element)๋ฅผ ๊ฐ์ง๋ฉฐ, ์ ๊ทธ๋ฆผ์ ๋ณด๋ฉด ์์๋ค์ด ์ฐ์์ ์ผ๋ก ๋๋ํ ๋ชจ์ฌ์๋ ๋ชจ์ต์ ๋ณผ ์ ์๋ค.
๊ฐ ์์๋ค์ ์์น๋ฅผ ๊ฐ์ง๊ณ , ํน์ ์์์ ์ ๊ทผํ๊ธฐ ์ํด์๋ ์ธ๋ฑ์ค(Index)๋ฅผ ํตํด ์ ๊ทผํ๋ค.
๋๋ถ๋ถ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ๋ฐฐ์ด ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํ๋ฉฐ, ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์์ ์ ๊ทผํ ๋์๋ 0๋ฒ์งธ ์์น์ ์ ๊ทผํ๋ ํํ๊ฐ ๋๋ค.
๋ํ, ์์ ํ์ธํ ๊ทธ๋ฆผ์ 1์ฐจ์(์ )์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๋์ดํ ์ํ์ธ๋ฐ, ์ด๋ฅผ ์ค์ฒฉ์์ผ ์๋์ ๊ฐ์ด ๋ ๋์ ์ฐจ์์ ๋ฐฐ์ด์ ๋ง๋ค์ด ์๋ฃ๋ฅผ ๊ด๋ฆฌํ ์๋ ์๋ค.
๋ฐฐ์ด์ ๊ฒฝ์ฐ ๋๋ถ๋ถ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ง์ํ๊ธฐ ๋๋ฌธ์ ์ง์ ๊ตฌํํ ํ์๋ ์๋ค.
๊ฐ๋
์ ์ด๋ ์ ๋ ์ตํ์ผ๋, C์ธ์ด๋ก ์ด๋ํ์ฌ ๋ฐฐ์ด์ ์ง์ ํ์ธํด๋ณด๋๋ก ํ์.
๐ ๋ฐฐ์ด ์ดํด๋ณด๊ธฐ
C์ธ์ด์์ ๋ฐฐ์ด์ ์๋์ ๊ฐ์ด ์ ์ธํ๋ค. (T๋ ์๋ฃํ์ ๋ํ๋ธ๋ค๊ณ ์ดํดํ์)
// T name[size];
int arr[8];
์ ์ฝ๋๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 8์ธ int ํ ๋ฐฐ์ด arr ์ ์ ์ธํ ์ฝ๋์ด๋ค.
๋ณ์ ์ ์ธ๊ณผ ํฌ๊ฒ ๋ค๋ฅผ๊ฑด ์๋ค. ๋จ์ง ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๋๊ดํธ ์์ ์ ์๋์ด์๋ค๋ ๊ฒ๋ฟ์ด๋ค.
์ถ๊ฐ๋ก 1์ฐจ์(์ ) ๋ฐฐ์ด ๋ง๊ณ ๋ค์ฐจ์ ๋ฐฐ์ด๋ ์๋์ ๊ฐ์ด ์ฝ๊ฒ ์ ์ธํ ์ ์๋ค.
int arr2[8][3]; // 8x3 ํฌ๊ธฐ์ 2์ฐจ์ ๋ฐฐ์ด
int arr3[8][3][3]; // 8x3x3 ํฌ๊ธฐ์ 3์ฐจ์ ๋ฐฐ์ด
...
๋ช ์ฐจ์์ด๋ ๋ฐฐ์ด ํฌ๊ธฐ๋ฅผ ์ ์ํด์ฃผ๊ธฐ๋ง ํ๋ฉด ๋๋ค.
๋ฐฐ์ด๋ ์ผ๋ฐ์ ์ธ ๋ณ์์ ๋์ผํ๊ฒ ์๋์ ๊ฐ์ด ์ ์ธ๊ณผ ๋์์ ๊ฐ์ ํ ๋นํ ์ ์๋ค.
int arr[8] = {27, 3, 7, 120, 40, 8, 13, 9};
// ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ ํ๋ ๊ฒฝ์ฐ ๋ฐฐ์ด ํฌ๊ธฐ๋ฅผ ์๋ตํด๋ ๋๋ค.
int arr[] = {27, 3, 7, 120, 40, 8, 13, 9};
// ๋ค์ฐจ์ ๋ฐฐ์ด์ ์๋์ ๊ฐ์ด ์ด๊ธฐํํ๋ค. (3x3)
int arr2[][] = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
(์ฐธ๊ณ ๋ก ๋ฐฐ์ด์ ์ ์ธ๋ง ํด๋ ์ํ์์, ์์์ ์ ๊ทผํ ๊ฒฝ์ฐ ๋ฉ๋ชจ๋ฆฌ ์์ ๋จ์์๋ ์ฐ๋ ๊ธฐ ๊ฐ์ ์ฐธ์กฐํ ์๋ ์๋ค)
์ฐ๋ฆฌ๊ฐ ์ ์ธํ ๋ฐฐ์ด ์์๋ ์ด 8๊ฐ์ ์์(int ํ ๊ฐ)๊ฐ ๋ค์ด์๋ค.
๋ฐฐ์ด์ ์์๋ ์ธ๋ฑ์ค๋ฅผ ํตํด ์ ๊ทผ ๊ฐ๋ฅํ๋ค๊ณ ์์ ์ค๋ช
ํ๋ค. ์ด ๋ํ ์ฝ๋๋ฅผ ํตํด ์ดํด๋ณด๋๋ก ํ์.
printf("%d", arr[2]); // 7
arr ๋ฐฐ์ด์ 2๋ฒ์งธ ์ธ๋ฑ์ค ์์๋ฅผ ์ฐธ์กฐํ์ฌ ์ถ๋ ฅํ๋ ์ฝ๋์ด๋ค. ์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํ๋ฏ๋ก 2๋ฒ์งธ ์ธ๋ฑ์ค์ ์ ๊ทผํ ๊ฒฝ์ฐ 3๋ฒ์งธ ๊ฐ์ ์ฐธ์กฐํ๊ฒ ๋๋ค. (๋ค์ฐจ์ ๋ฐฐ์ด๋ ๋์ผํ๊ฒ ์ ๊ทผํ๋ฉด ๋๋ค.)
์ด๋ฒ์๋ ๋ฐฐ์ด ์์๋ฅผ ๋ชจ๋ ์ถ๋ ฅํด๋ณด๋๋ก ํ์.
#include <stdio.h>
int main(void)
{
int arr[] = {27, 3, 7, 120, 40, 8, 13, 9};
for (int i = 0; i < 8; i++)
{
printf("%d %d\n", i, arr[i]);
}
return 0;
}
// Result
0 27
1 3
2 7
3 120
4 40
5 8
6 13
7 9
์ฝ๋๋ฅผ ๊ฐ๋ตํ ์ดํด๋ณด๋ฉด, ์ ์ธํ ๋ฐฐ์ด arr์ ์์์ ์ ๊ทผํ๊ณ ์ถ๋ ฅํ๊ธฐ ์ํด for๋ฌธ์ ํ์ฉํ๋ค.
for๋ฌธ์์ ์ฌ์ฉํ๋ ๋ณ์ i ๋ ๋ฐฐ์ด ์ธ๋ฑ์ค ๋ณ์๋ก์จ ์ฌ์ฉ๋๊ณ ์๋ค.
i๋ 0~7๊น์ง ์ฆ๊ฐํ๊ฒ ๋๊ณ , ๋ฐ๋ณต๋ฌธ ๋ด์์๋ arr ๋ฐฐ์ด ์์์ ์ ๊ทผํ์ฌ ์ถ๋ ฅํ๊ณ ์๋ค.
๐ฅ ๋ ์์๋ณด๊ธฐ
๋ง์ง๋ง์ผ๋ก ๋ฐฐ์ด์ ๋ํด ์กฐ๊ธ ๋ ๊น๊ฒ ์์๋ณด๋๋ก ํ์.
๋ฐฐ์ด์ ์์๊ฐ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋์ด์๋ ํํ์ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ๊ฐ๊ณ ์๋ค.
์ฌ๋ฌ ์์๋ฅผ ๋ด์ ์ ์๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ์ด๋ค์ง ๊ถ๊ธํ์ง ์์๊ฐ?
ํ ๋ฒ ์๋ ์์ ์ฝ๋๋ฅผ ํตํด ์ดํด๋ณด๋๋ก ํ์.
#include <stdio.h>
int main(void)
{
int arr[] = {27, 3, 7, 120, 40, 8, 13, 9};
printf("%lu\n", sizeof(int));
printf("%lu\n", sizeof(arr));
return 0;
}
// Result
4
32
C์ธ์ด์์๋ sizeof ๋ฅผ ํตํด ์๋ฃํ์ ํฌ๊ธฐ๋ฅผ ์ ์ ์๋ค. ์ฝ๋๋ฅผ ์คํํด๋ณด๋ฉด ์๋์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
- int: 4๋ฐ์ดํธ
- arr: 32๋ฐ์ดํธ
4๋ฐ์ดํธ๋ก ์ ์๊ฐ์ ๋ํ๋ด๋ ์๋ฃํ์ int ์ด๋ค.
์ฐ๋ฆฌ๊ฐ ์ ์ธํ ๋ฐฐ์ด์ int ํ ๋ฐฐ์ด์ด๋ฏ๋ก arr ์ ํฌ๊ธฐ๋ int ํ ํฌ๊ธฐ x ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๋๋ค.
8๊ฐ์ ์์๋ฅผ ๊ฐ๋ ๋ฐฐ์ด์ด๋ฏ๋ก, arr ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 4 x 8 = 32 ๋ฐ์ดํธ๊ฐ ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ์ค์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ ์์์ ๊ฐ ์์๊ฐ 4๋ฐ์ดํธ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๊ณ ์๋์ง ํ์ธํด๋ณด์.
#include <stdio.h>
int main(void)
{
int arr[] = {27, 3, 7, 120, 40, 8, 13, 9};
for (int i = 0; i < 8; i++)
{
printf("%p\n", &arr[i]); // &๋ ๋ฉ๋ชจ๋ฆฌ ์์น๋ฅผ ๋ฐํํ๋ค.
}
return 0;
}
// Result
0x7ff7b855a6c0
0x7ff7b855a6c4
0x7ff7b855a6c8
0x7ff7b855a6cc
0x7ff7b855a6d0
0x7ff7b855a6d4
0x7ff7b855a6d8
0x7ff7b855a6dc
(C์ธ์ด์์๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ 16์ง์๋ก ํํํ๋ค)
์ถ๋ ฅ๋ ๊ฒฐ๊ณผ๋ฅผ ์ดํด๋ณด๋ฉด ๊ฐ ์์๊ฐ 4๋ฐ์ดํธ์ ๊ฐ๊ฒฉ์ ์ ์งํ๊ณ ์๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
์ง๊ธ๊น์ง ๋ฐฐ์ด์ ๋ํด ์์๋ณด์๋ค.
์ฌ๋ฌ๊ฐ์ ๋์ด๋ ์๋ฃ๋ฅผ ๊ด๋ฆฌํ ๋ ๋ฐฐ์ด์ ํ์ฉํ ์ ์๊ณ , ๋น๋ฒํ๊ฒ ์ฌ์ฉํ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ ๋ฐ๋์ ์์งํด์ผํ๋ค.