
Unused์ C์ธ์ด ํฌ์ธํฐ ์๋ฆฌ์ฆ
ํฌ์คํธ | URL |
---|---|
C์ธ์ด์ ํฌ์ธํฐ (๊ธฐ์ด) | https://unused.tistory.com/221 |
C์ธ์ด์ ํฌ์ธํฐ ์ดํด: ์ ์ธ์ผ๋ก์์ *, ์ฐ์ฐ์๋ก์์ * | https://unused.tistory.com/217 |
C์ธ์ด์ ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ | https://unused.tistory.com/220 |
C์ธ์ด์ ๋ค์ค ํฌ์ธํฐ | https://unused.tistory.com/215 |
์ ์ด๋ฏธ์ง์ for๋ฌธ์ ํ๋ฒ ๋ณด์์ง์. ํ์ ์ง๋ ๊ฒ๊ณผ๋ ๋ค๋ฅด์ง ์์ผ์ ๊ฐ์? C์ธ์ด์์๋ ๋ฐฐ์ด์ด ๊ณง ํฌ์ธํฐ์ฒ๋ผ ๋์ํ๊ธฐ์ ๊ฐ๋ฅํฉ๋๋ค.
int arr[5] = {10, 20, 30, 40, 50};
int *p = arr; // p๋ arr์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ
์ฌ๊ธฐ์ arr
์ ๋ฐฐ์ด ์ ์ฒด๋ฅผ ์๋ฏธํ์ง๋ง, ๋๋ถ๋ถ์ ๋ฌธ๋งฅ์์๋ &arr[0]
— ์ฆ, ์ฒซ ๋ฒ์งธ ์์์ ์ฃผ์๋ก ์๋ ๋ณํ๋ฉ๋๋ค. ๋ฐ๋ผ์ p
๋ arr[0]
์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๊ฐ ๋์ฃ . ์ดํ p[2]
, *(p + 2)
๋ฑ์ ๋ฌธ๋ฒ์ ํตํด ๋ฐฐ์ด์ ๊ฐ์ ์ ๊ทผํ ์ ์์ต๋๋ค.
printf("%d\n", arr[2]); // 30
printf("%d\n", *(arr + 2)); // 30
printf("%d\n", p[2]); // 30
์ฆ, arr
์ int
5๊ฐ์ง๋ฆฌ ๋ฉ์ด๋ฆฌ์ด๋ฉด์, ๋์์ ๊ทธ ์์ ์์น๋ฅผ ๋ํ๋ด๋ ์ฃผ์์ฒ๋ผ๋ ์ฐ์ด๋ ๊ฒ์
๋๋ค. ์ฐ๋ฆฌ๊ฐ scanf()
์ ๋ฌธ์์ด(char[]
)์ ๋๊ธธ ๋๋ง &
๋ฅผ ์ ๋ถ์ด๋ ์ด์ ๊ฐ ๋ฐ๋ก ์ด๊ฒ์
๋๋ค.
์๋๊ฐ ๋ฐ๋ก ๊ทธ๋ฌํ ์์์
๋๋ค. (func()
์ ์ธ์์ &
๋ฅผ ๋ถ์ด์ง ์์๋ค๋ ์ ์ ์ฃผ๋ชฉ)
#include <stdio.h>
void func(int* arr, int count) {
for(int i=0; i<count; i++)
arr[i] = arr[i]*3; // 3๋ฐฐ!
}
int main() {
int arr[5] = {1, 2, 3};
for (int i = 0; i < 5; i++) printf("%d ", arr[i]); // ์ถ๋ ฅ ๊ฒฐ๊ณผ: 1, 2, 3
func(arr, 5); // &arr์ด ์๋๋ผ arr์ ๋ฃ์!
for (int i = 0; i < 5; i++) printf("%d ", arr[i]); // ์ถ๋ ฅ ๊ฒฐ๊ณผ: 3, 6, 9
return 0;
}
์ฃผ์์ฌํญ
๋ฐฐ์ด ๋ณ์์ ํฌ์ธํฐ ๋ณ์๊ฐ ์์ ํ ๋์ผํ๊ฒ ๋์ํ์ง๋ ์์ต๋๋ค. ์๋ ์ฝ๋๋ฅผ ๋ด์ฃผ์ธ์.
int arr[5];
int *p = arr;
printf("%zu\n", sizeof(arr)); // 20 (int 4๋ฐ์ดํธ × 5๊ฐ)
printf("%zu\n", sizeof(p)); // 8 (64๋นํธ ํฌ์ธํฐ์ ํฌ๊ธฐ)
์ถ๋ ฅ๋๋ ๊ฒฐ๊ณผ๊ฐ ๋ค๋ฆ
๋๋ค. ์ฌ์ฉ๋ฒ์ด ๊ฑฐ์ ๋น์ทํด๋ ๊ฒฐ๊ตญ arr
๊ณผ p
๋ ๋ณ๊ฐ์ ์๋ฃํ์ด๊ธฐ ๋๋ฌธ์
๋๋ค.
2์ฐจ์ ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ
๊ฐ๋ น ์๋์ ๊ฐ์ 5ํ 3์ด (3x5) ๋ฐฐ์ด์ ๊ฐ์ ํฉ์๋ค. ์ด๋ ์ฆ int[3]์ง๋ฆฌ ๋ฐฐ์ด์ 5๊ฐ ์๋ ๊ฒ์ด๊ฒ ์ฃ ?
int arr[5][3] = {
{ 1, 2, 3 },
{ 4, 5, 6 },
{ 7, 8, 9 },
{10, 11, 12 },
{13, 14, 15 }
};
์๋์ ๊ฐ์ด ์ ์ธํ๋ฉด, 3๊ฐ ์ด์ ๋ด๋ (= int[3]์ ๋ด๋) 1๊ฐ ํ์ง๋ฆฌ ํฌ์ธํฐ p๊ฐ ๋ฉ๋๋ค. ์ด๋ ๊ดํธ๊ฐ ์ค์ํฉ๋๋ค. ๋ฐฐ์ด์ ์ ์ธ์ด `int arr[10];` ๊ฐ์ ์์ด๊ณ , ๋ฐฐ์ด์ ํฌ์ธํฐ์ ์ ์ธ์ ๋ณ์ด ์ค๊ฐ์ ๋ค์ด๊ฐ์ผ ํ๋๋ฐ, ๊ดํธ๋ฅผ `int (* p) [10];`์ ๊ฐ์ด ๋ฌถ์ด์ผ๋ง ์ ์์ ์ผ๋ก ํด์๋ฉ๋๋ค.
int (*p)[3];
p = arr;
/* "3๊ฐ์ int๋ก ๊ตฌ์ฑ๋ ๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ"๋ฅผ ์ ์ธ, arr์ ๋งจ ์ ์ฃผ์๋ฅผ ๋์
.
์ฆ,
โ p์ ํ์
์ "ํฌ์ธํฐ"
โ *p์ ํ์
์ "int[3]"
โ p[i]๋ i๋ฒ์งธ ํ(๋ฐฐ์ด)
โ p[i][j]๋ ๊ทธ ํ์ j๋ฒ์งธ ์์
*/
๋ค์ฐจ์ ๋ฐฐ์ด๊ณผ ๋ค์ค ํฌ์ธํฐ
ํํธ, ๋ค์ฐจ์ ๋ฐฐ์ด์ ๋ค์ค ํฌ์ธํฐ๋ก ์ ๊ทผํ ์๋ ์์๊น์? ๋จผ์ ๋จ์ผ ํฌ์ธํฐ๋ฅผ ์ด์ฉํ ์ ์์ ์ธ ์์๋ถํฐ ๋ณด์ฌ๋๋ฆฌ๊ฒ ์ต๋๋ค.
// ์ ์์ ์ธ ์์
#include <stdio.h>
void printMatrix3D(int (*matrix)[3][4], int depth, int rows, int cols) {
for (int k = 0; k < depth; k++) {
printf("Depth %d:\n", k);
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++)
printf("%3d ", matrix[k][i][j]);
printf("\n");
}
printf("\n");
}
}
void modifyMatrix3D(int (*matrix)[3][4], int depth, int rows, int cols) {
for (int k = 0; k < depth; k++) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++)
matrix[k][i][j] = matrix[k][i][j]*10; // 10๋ฐฐ!
}
}
}
int main() {
int myArray[2][3][4] = {{
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
},{ {13, 14, 15, 16},
{17, 18, 19, 20},
{21, 22, 23, 24}
}
};
printf("์์ ์ :\n");
printMatrix3D(myArray, 2, 3, 4);
printf("modifyMatrix3D๋ก ๋ค์ด๊ฐ๋๋ค...\n");
modifyMatrix3D(myArray, 2, 3, 4);
printf("modifyMatrix3D ์๋ฃ!\n");
printf("\n์์ ํ:\n");
printMatrix3D(myArray, 2, 3, 4);
return 0;
}
์คํ ๊ฒฐ๊ณผ๋ ์๋์ ๊ฐ์ต๋๋ค.
์ ์ฝ๋์ modify ๋ฐ print ํจ์๋ค์ ์ธ์๋ค์, ๊ทธ๋ฅ void printMatrix3D(int (**matrix)[4], ...
๋ void printMatrix3D(int ***matrix, ...
์ฒ๋ผ ๋ค์ค ํฌ์ธํฐ๋ก ๋ฐ์ผ๋ฉด ์๋ ๊น ์ถ์ผ์ค ์ ์์ต๋๋ค. ๊ฒฐ๋ก ์ ์ผ๋ก ๋ถ๊ฐ๋ฅํฉ๋๋ค. ์ด๋ ํฌ์ธํฐ ์คํ์
๊ณ์ฐ(+,-)๊ณผ ๊ด๋ จ์ด ์์ต๋๋ค.
์ต์ง๋ก ๋ค์ค ํฌ์ธํฐ ์จ๋ณด๊ธฐ
// ์๋ชป๋ ์์์
๋๋ค!!
#include <stdio.h>
// ์ต์ง๋ก ***๋ฅผ ์ฌ์ฉ
void modifyMatrix3D(int ***matrix, int depth, int rows, int cols) {
for (int k = 0; k < depth; k++) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++)
matrix[k][i][j] *= 10; // 10๋ฐฐ
}
}
}
// ์ต์ง๋ก ***๋ฅผ ์ฌ์ฉ
void printMatrix3D(int ***matrix, int depth, int rows, int cols) {
for (int k = 0; k < depth; k++) {
printf("Depth %d:\n", k);
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++)
printf("%3d ", matrix[k][i][j]);
printf("\n");
}
printf("\n");
}
}
int main() {
int myArray[2][3][4] = {{
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
},{ {13, 14, 15, 16},
{17, 18, 19, 20},
{21, 22, 23, 24}
}
};
// ์ต์ง๋ก int***๋ก ์บ์คํ
int ***p = (int ***) myArray;
printf("์์ ์ :\n");
printMatrix3D(p, 2, 3, 4);
printf("modifyMatrix3D๋ก ๋ค์ด๊ฐ๋๋ค...\n");
modifyMatrix3D(p, 2, 3, 4);
printf("modifyMatrix3D ์๋ฃ!\n");
printf("\n์์ ํ:\n");
printMatrix3D(p, 2, 3, 4);
return 0;
}
์๋ ์ต์ง๋ก ๋ค์ค ํฌ์ธํฐ๋ฅผ ์ด์ฉํ๋ ์๋ชป๋ ์์์ ๋๋ค.
์๋ฅผ ๋ค์ด, printMatrix3D()์ ์ผ์คํฌ์ธํฐ matrix์ ๋ํ์ฌ, matrix[k][i][j]๋ *(*(*(matrix+k)+i)+j)๋ก ํด์๋ ์ ์์ต๋๋ค. k=0, i=0, j=0, matrix[0][0][0]=1์ด๋ผ ์น ๋, ์ด๋ฅผ ํ๋ํ๋ ํ์ด๋๊ฐ๋ด ์๋ค.
- ๋จผ์ matrix+0, ์ฆ, 1์ด๋ผ๋ ๊ฐ์ด ๋์ต๋๋ค. ์์ *(*(*(1)+i)+j)๋ก ํ๋ฆฝ๋๋ค.
- *(1)์ด๋, 0x00000001์ด๋ผ๋ ์ฃผ์์ ๋ ๊ฐ์ ๊ฐ์ ธ์จ๋ค๋ ๋ป์ ๋๋ค(32๋นํธ ์์คํ ๊ธฐ์ค). 0x00000001์๋ ๋ฌด์์ด ๋ค์์๊น์?
- ์๋ฌดํผ *(*(*(1)+i)+j) = *(*(0x00000001์ ๋ ์ฐ๋ ๊ธฐ๊ฐ+i)+j) ๊ฐ์ ์์ผ๋ก ๋ฉ๋๋ค.
- ์ด๋ฅผ ๋ ํ๋ฉด ๋ ์ด๋ ํ ์ฐ๋ ๊ธฐ๊ฐ์ด ๋์ค๊ณ , ์ด๋ฅผ ํฌ์ธํฐ๋ก ํด์ํ์ฌ ์ฐธ์กฐํ๊ณ , ๋ ์ฐ๋ ๊ธฐ๊ฐ์ด ๋์ค๊ณ , ๋ ์ฐธ์กฐํ๊ณ , ...
์ด๋ฐ ์์ผ๋ก ์ธ๊ฐ์ด ์๋ํ ๋ฐ์๋ ์์ ํ ๋ค๋ฅธ ๊ฒฐ๊ณผ๊ฐ ๋์ต๋๋ค. ๋๋ฌธ์ int[2][3][4]๊ฐ์ ๋ค์ฐจ์ ๋ฐฐ์ด์ ๋ฐ๋์ ์ ํํ ์ผ์นํ๋ ํฌ์ธํฐ ํ์ (์: int (*)[3][4])์ผ๋ก ๋ฐ์์ผ๋ง ๊ทธ์ ๋ง๋ ์คํ์ ๊ณ์ฐ์ด ๊ฐ๋ฅํฉ๋๋ค. ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ ์์ ๊ฐ์ด ์ค๋์ ๋๋ ์ธ๊ทธ๋ฉํ ์ด์ ์ค๋ฅ(segmentation fault)๊ฐ ๋ฐ์ํฉ๋๋ค.
์ฐธ๊ณ ๋ก, ์ ์๋ชป๋ ์์์ ์คํ ๊ฒฐ๊ณผ๋ ์๋์ ๊ฐ์ต๋๋ค (์ฐ๋ถํฌ).
์๋๋ ๋ฉ๋ชจ๋ฆฌ ๋ณดํธ๊ฐ ์๋ MS-DOS์์ ๋์ผ ์ฝ๋๋ฅผ ์คํํ ๊ฒฐ๊ณผ์ ๋๋ค. ์์ ํ ์๋ฑํ ๊ฐ์ด ๋์ด์ ์ ์ ์์ต๋๋ค.
'IT > ์ปดํจํ ์ ์ฌ๊ณ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Pintos Part 1-1. Busy Waiting vs. Sleep/Wakeup (0) | 2025.05.12 |
---|---|
๋ ๋-๋ธ๋ ํธ๋ฆฌ (Red-Black Tree) (1) | 2025.04.18 |
C์ธ์ด์ ํฌ์ธํฐ (๊ธฐ์ด) (0) | 2025.04.17 |
C์ธ์ด์ ํฌ์ธํฐ ์ดํด: ์๋ฃํ์ผ๋ก์์ *์ ์ญ์ฐธ์กฐ ์ฐ์ฐ์๋ก์์ * (2) | 2025.04.14 |
C์ธ์ด์ ๋ค์ค ํฌ์ธํฐ (0) | 2025.04.13 |
์ด๋ถ ํ์๊ณผ Python์ bisect_left (0) | 2025.03.27 |
Python ์ปดํ๋ฆฌํจ์ ๋ฐ ํํ์ ์ ๋ฆฌ (0) | 2025.03.27 |
์๋ ํ์ธ์.
ํฌ์คํ ์ด ์ข์๋ค๋ฉด "์ข์์โค๏ธ" ๋๋ "๊ตฌ๋ ๐๐ป" ํด์ฃผ์ธ์!