ใ์ค์ฑ์ฐ์ ์ดํ C ํ๋ก๊ทธ๋๋ฐใ ์ ์ฐธ๊ณ ํ์์ต๋๋ค.
ใ์ค์ฑ์ฐ์ ์ดํ C ํ๋ก๊ทธ๋๋ฐใ ์ค ํท๊ฐ๋ ธ๋ ๋ด์ฉ์ ์ ๋ฆฌํฉ๋๋ค.
16-1 ; ๋ค์ฐจ์ ๋ฐฐ์ด์ ์ดํด์ ํ์ฉ
'๋ค์ฐจ์ ๋ฐฐ์ด' 2์ฐจ์ ์ด์์ ๋ฐฐ์ด.
2์ฐจ์ ๋ฐฐ์ด : ํ๋ฉด๊ตฌ์กฐ์ ๋ฐฐ์ด
3์ฐจ์ ๋ฐฐ์ด : ์ง์ก๋ฉด์ฒด ๊ตฌ์กฐ์๋ฐฐ์ด
4์ฐจ์ ์ด์์ ๋ฐฐ์ด์ ์ธ์ ๋ฌธ๋ฒ์ ์ผ๋ก ํ์ฉํ์ง๋ง ๋ถํ์ํ๊ณ ๋ ผ๋ฆฌ์ ์ผ๋ก ์ดํดํ๊ธฐ๋ ์ด๋ ค์ด ํํ๋ค.
2์ฐจ์ ๋ฐฐ์ด์ ์ ์ธ
TYPE arr[์ธ๋ก๊ธธ์ด][๊ฐ๋ก๊ธธ์ด];
int arr1[3][4]; // ์ธ๋ก๊ฐ 3, ๊ฐ๋ก๊ฐ 4์ธ intํ 2์ฐจ์ ๋ฐฐ์ด
int arr2[2][6]; // ์ธ๋ก๊ฐ 2, ๊ฐ๋ก๊ฐ 6์ธ intํ 2์ฐจ์ ๋ฐฐ์ด
sizeof์ฐ์ฐ์์ ํผ์ฐ์ฐ์๋ก ๋ฐฐ์ด์ ์ด๋ฆ์ด ์ค๋ฉด ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๋ฐ์ดํธ ๋จ์๋ก ๊ณ์ฐ๋์ด์ ๋ฐํ๋๋ค. 2์ฐจ์๋ฐฐ์ด์์๋!
2์ฐจ์ ๋ฐฐ์ด์์์ ์ ๊ทผ
arr[N-1][M-1]=20; // ์ธ๋ก N, ๊ฐ๋ก M์ ์์น์ ์ ์ 20์ ์ ์ฅ
printf("%d", arr[N-1][M-1]); // ์ธ๋ก N, ๊ฐ๋ก M์ ์์น์ ์ ์ฅ๋ ๊ฐ ์ถ๋ ฅ
2์ฐจ์ ๋ฐฐ์ด -> for๋ฌธ์ ์ค์ฒฉ์ํค๋ ๊ฒ ์ผ๋ฐ์ ์ด๊ณ ๊ฐ์ฅ ์ฌ์ด ๋ฐฉ๋ฒ.
2์ฐจ์์ ๋ชจ๋ธ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์๋ 2์ฐจ์ ๋ฐฐ์ด์ ์ ์ธํ๋ ๊ฒ ๋ฐ๋์งํ๋ค.
2์ฐจ์ ๋ฐฐ์ด์ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น์ ํํ
์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ๋ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์ ๊ฐ์ 1์ฐจ์์ ๊ตฌ์กฐ
2์ฐจ์ ๋ฐฐ์ด๋ ๋ฉ๋ชจ๋ฆฌ์์๋ 1์ฐจ์์ ํํ๋ก ์กด์ฌํจ.
#include <stdio.h>
int main(void) {
int arr[3][2];
int i, j;
for(i=0; i<3; i++)
for(j=0; j<2; j++)
printf("%p \n", &arr[i][j]);
return 0;
}
๋ฐฐ์ด์์ ๋ณ ์ฃผ์ ๊ฐ์ intํ ๋ณ์ ํฌ๊ธฐ์ธ 4๋ฐ์ดํธ๋งํผ๋ง ์ฐจ์ด๊ฐ ๋๋ค.
2์ฐจ์ ๋ฐฐ์ด ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํํ๊ธฐ
์ด๊ธฐํ ๋ฆฌ์คํธ ์์๋ ํ ๋จ์๋ก ์ด๊ธฐํํ ๊ฐ๋ค์ ๋ณ๋์ ์ค๊ดํธ๋ก ๋ช ์ํด์ผ ํ๋ค.
๋น๊ฒ ๋๋ ๊ณต๊ฐ์ 1์ฐจ์ ๋ฐฐ์ด์ ๊ฒฝ์ฐ์ ๋ง์ฐฌ๊ฐ์ง๋ก 0์ผ๋ก ์ด๊ธฐํ๋๋ค.
int arr[3][3] = { {1}, {4, 5}, {7, 8, 9} };
int arr[3][3] = { {1, 0, 0}, {4, 5, 0}, {7, 8, 9} };
์๋๋ 1ํ 1์ด๋ถํฐ ์์ํด์ ๋ฐฐ์ด์ ๋ง์ง๋ง์์๊น์ง ์์๋๋ก ๊ฐ์ด ์ด๊ธฐํ๋๋ ์ ์ธ ๋ฐฉ๋ฒ์ด๋ค.
int arr[3][3] = {1, 2, 3, 4, 5, 6, 7};
int arr[3][3] = {1, 2, 3, 4, 5, 6, 7, 0, 0};โ
๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์๋ ค์ฃผ์ง ์๊ณ ์ด๊ธฐํํ๊ธฐ
2์ฐจ์ ๋ฐฐ์ด๋ ์ด๊ธฐํ ๋ฆฌ์คํธ๊ฐ ์กด์ฌํ๋ค๋ฉด, ๊ทธ ๊ธธ์ด๋ฅผ ๋ช ์ํ์ง ์์๋ ๋๋ค.
์ปดํ์ผ๋ฌ๊ฐ ๊ฐ๋ก์ ์ธ๋ก์ ๊ธธ์ด๋ฅผ ๋ชจ๋ ์์ธกํ๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํ๋ฏ๋ก,
๋ฐฐ์ด์ ์ธ๋ก๊ธธ์ด๋ง ์๋ต์ด ๊ฐ๋ฅํ๋ค.
int arr1[][4] = {1, 2, 3, 4, 5, 6, 7, 8};
int arr2[][2] = {1, 2, 3, 4, 5, 6, 7, 8};
๋ฌธ์ 16-1 [2์ฐจ์ ๋ฐฐ์ด์ ํ์ฉ]
- ๋ฌธ์ 1 : ๊ตฌ๊ตฌ๋จ 2, 3, 4๋จ
// ๊ฐ๋ก ๊ธธ์ด๊ฐ 9, ์ธ๋ก ๊ธธ์ด๊ฐ 3์ธ intํ 2์ฐจ์ ๋ฐฐ์ด์ ์ ์ธํ์ฌ
// ๊ตฌ๊ตฌ๋จ 2,3,4๋จ ์ ์ฅ ํ ์ถ๋ ฅ
#include <stdio.h>
int main(int argc, const char * argv[]) {
int arr[3][9];
for(int i=0; i<3; i++){
printf("๊ตฌ๊ตฌ๋จ ์ค %d๋จ: ", i+2);
for(int j=0; j<9; j++){
arr[i][j] = 1;
arr[i][j] = (j+1) * (i+2);
printf("%d ", arr[i][j]);
}
printf("\n");
}
return 0;
}
- ๋ฌธ์ 2 : ๋ฐฐ์ด์ ์ด๊ณผ ํ ๋ฐ๊พธ๊ธฐ
// ๋ฐฐ์ด์ ์ด๊ณผ ํ์ ๋ฐ๊พธ๋ ๋ฌธ์
#include <stdio.h>
int main(int argc, const char * argv[]) {
int arrA[2][4] = {1, 2, 3, 4, 5, 6, 7, 8}; // ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ
printf("๋ฐฐ์ด A \n");
for(int i=0; i<2; i++){
for(int j=0; j<4; j++){
printf("%d ",arrA[i][j]);
}
printf("\n");
}
printf("\n");
int arrB[4][2] = {0};
printf("๋ฐฐ์ด B \n");
for(int i=0; i<4; i++){
for(int j=0; j<2; j++){
arrB[i][j] = arrA[j][i];
printf("%d ",arrB[i][j]);
}
printf("\n");
}
return 0;
}
- ๋ฌธ์ 3 : ์ฑ์ ๊ด๋ฆฌ ํ๋ก๊ทธ๋จ
// ์ฑ์ ๊ด๋ฆฌํ๋ก๊ทธ๋จ
// ๋ฐฐ์ด 5*5
// ๊ตญ์ด, ์์ด, ์ํ, ๊ตญ์ฌ
// ์ฒ ํฌ, ์ฒ ์, ์ํฌ, ์์
// ์ฌ์ฉ์๋ก๋ถํฐ ๋ค ์ฌ๋์ ๋ค ๊ณผ๋ชฉ ์ ์ ์
๋ ฅ ๋ฐ์
// ๋ฏธ๋ฆฌ ์ ์ธํด ๋์ ๋ฐฐ์ด์ ๋ค์์ ํํ๋ก ๊ทธ ๊ฐ์ ์ ์ฅ
// ๊ฐ์ธ๋ณ ์ด์ ๊ณผ ๊ณผ๋ชฉ๋ณ ์ด์ ์ ๊ณ์ฐํด์ ์ ์ฅํด์ 5ํ, 5์ด์ ์ถ๋ ฅ
#include <stdio.h>
int main(int argc, const char * argv[]) {
int arr[5][5] = {0};
printf("์ฒ ํฌ์ ์ ์๋ฅผ ์
๋ ฅํ์์ค. (๊ตญ์ด ์์ด ์ํ ๊ตญ์ฌ) : ");
scanf("%d %d %d %d", &arr[0][0], &arr[0][1], &arr[0][2], &arr[0][3]);
printf("์ฒ ์์ ์ ์๋ฅผ ์
๋ ฅํ์์ค. (๊ตญ์ด ์์ด ์ํ ๊ตญ์ฌ) : ");
scanf("%d %d %d %d", &arr[1][0], &arr[1][1], &arr[1][2], &arr[1][3]);
printf("์ํฌ์ ์ ์๋ฅผ ์
๋ ฅํ์์ค. (๊ตญ์ด ์์ด ์ํ ๊ตญ์ฌ) : ");
scanf("%d %d %d %d", &arr[2][0], &arr[2][1], &arr[2][2], &arr[2][3]);
printf("์์์ ์ ์๋ฅผ ์
๋ ฅํ์์ค. (๊ตญ์ด ์์ด ์ํ ๊ตญ์ฌ) : ");
scanf("%d %d %d %d", &arr[3][0], &arr[3][1], &arr[3][2], &arr[3][3]);
for(int i=0; i<4; i++){
for (int j=0; j<4; j++){
arr[i][4] += arr[i][j]; // ํ์๋ณ ์ด์ ์ ์ฅ
arr[4][i] += arr[j][i]; // ๊ณผ๋ชฉ๋ณ ์ด์ ์ ์ฅ
}
arr[4][4] += arr[4][i];
}
for(int i=0; i<5; i++){
for(int j=0; j<5; j++){
printf("%d ", arr[i][j]); // ๋ฐฐ์ด ์ ์ฒด ์ถ๋ ฅ
}
printf("\n");
}
return 0;
}
16-2 ; 3์ฐจ์ ๋ฐฐ์ด
int arr1[2][3][4]; //๋์ด 2, ์ธ๋ก 3, ๊ฐ๋ก 4์ธ intํ 3์ฐจ์ ๋ฐฐ์ด
double arr2[5][5][5]; //๋์ด, ์ธ๋ก, ๊ฐ๋ก๊ฐ ๋ชจ๋ 5์ธ doubleํ 3์ฐจ์ ๋ฐฐ์ด
printf("%d \n", sizeof(arr1)); // 96 ์ถ๋ ฅ = (๋์ด 2 * ์ธ๋ก 3 * ๊ฐ๋ก 4) * int 4
printf("%d \n", sizeof(arr2)); // 1000 ์ถ๋ ฅ = (๋์ด 5 * ์ธ๋ก 5 * ๊ฐ๋ก 5) * double 8
3์ฐจ์ ๋ฐฐ์ด์ ๋ ผ๋ฆฌ์ ์ผ๋ก ์ง์ก๋ฉด์ฒด ํํ์ ๋ฐฐ์ด์ด๋ค.
3์ฐจ์ ๋ฐฐ์ด์ ์ ์ธ๊ณผ ์ ๊ทผ
2์ฐจ์ ๋ฐฐ์ด์ ์ด๊ธฐํ ๋ฆฌ์คํธ๋ 1์ฐจ์ ๋ฐฐ์ด์ ์ด๊ธฐํ ๋ฆฌ์คํธ๊ฐ ๋ค์ ๋ชจ์ฌ์๋ ํํ์ด๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก 3์ฐจ์ ๋ฐฐ์ด์ ์ด๊ธฐํ ๋ฆฌ์คํธ๋ ๋ค์์ 2์ฐจ์ ๋ฐฐ์ด ์ด๊ธฐํ ๋ฆฌ์คํธ๋ก ์ด๋ค์ ธ ์๋ ํํ์ด๋ค.
int record[3][3][2]={ // 3์ฐจ์ ๋ฐฐ์ด ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ
{
{70, 80},
{94, 90},
{70, 82}
},
{
{60, 39},
{76, 63},
{85, 97}
},
{
{99, 98},
{96, 98},
{92, 95}
}
};
3์ฐจ์ ๋ฐฐ์ด์ ์ฌ๋ฌ ๊ฐ์ 2์ฐจ์ ๋ฐฐ์ด์ด ๋ชจ์ฌ์๋ ํํ๋ก ์ดํดํ๋ ๊ฒ์ด ๋ ํฉ๋ฆฌ์ ์ด๋ค.