
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 |
์ธํธ๋ก
์๋์ ๊ฐ์ C ์ฝ๋๊ฐ ์์ต๋๋ค.
void main() {
int value = 123;
int *ptr1 = &value;
printf("*ptr1: %d\n", *ptr1); // ์ถ๋ ฅ ๊ฒฐ๊ณผ 123
*ptr1 = 456;
printf("*ptr1: %d\n", *ptr1); // ์ถ๋ ฅ ๊ฒฐ๊ณผ 456
}
๋ญ๊ฐ ์ด์ํฉ๋๋ค. ๋ถ๋ช
int * ptr1 = &value
์์ ์ฃผ์๊ฐ(&value)์ ๋์
ํ์ต๋๋ค. ๊ทผ๋ฐ ๊ทธ ์๋์๋ ๊ฐ(456)์ ๋์
ํ๋ค์. ๊ทธ๋ฆฌ๊ณ *ptr1
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ ๋ ๋ค ๊ฐ์ด๋ค์ (123 → 456)?
ํฌ์ธํฐ์ ๋ํด ๊ณต๋ถํ๋ค ๋ณด๋ฉด ํผ๋์ค๋ฌ์ด ๊ฒ ์ค ํ๋๊ฐ ๋ฐ๋ก, ํฌ์ธํฐ ๋ณ์ ์ ์ธ ์ ์ฌ์ฉํ๋ ์๋ฃํ *
์, ์ญ์ฐธ์กฐ ์ฐ์ฐ์(dereference operator) *
, ๊ทธ๋ฆฌ๊ณ ์ฃผ์ ์ฐธ์กฐ ์ฐ์ฐ์ &
์
๋๋ค. ํนํ ์๋ฃํ์ผ๋ก์์ *์ ์ญ์ฐธ์กฐ ์ฐ์ฐ์๋ก์์ *๋ ์ญํ ์ด ๋ฏธ๋ฌํ๊ฒ ๋ค๋ฅด๋ฉด์๋, ๋์ผํ ๊ธฐํธ๋ฅผ ์ฌ์ฉํ๊ธฐ์, ํฌ์ธํฐ ๊ฐ๋
์ ์ฒ์ ์ ํ ๋ ํท๊ฐ๋ฆฌ๊ธฐ๊ฐ ๋๋ฌด๋ ์ฝ์ต๋๋ค.
์ด๋ฒ ํฌ์คํธ์์๋ ์ด ์ธ ๊ฐ์ง๋ฅผ ํ์คํ ๊ตฌ๋ถํ๊ณ ์ดํดํ ์ ์๋๋ก ์ง์ค์ ์ผ๋ก ๋ค๋ฃจ์ด๋ณด๊ฒ ์ต๋๋ค.
1. ์๋ฃํ์ผ๋ก์์ * (์ ์ธ, ํ์ ์บ์คํ ๋ฑ)
์ฌ๊ธฐ์์ *
๋ int*
, char*
, float*
๋ฑ, ์๋ฃํ์ผ๋ก์์ *
์ญํ ์
๋๋ค. ์ด์ชฝ์ ์ฃผ์๊ฐ์ ๋ด๋ ํฌ์ธํฐ ๋ณ์์ ์ ์ธ์ด๋ ํ์
์บ์คํ
๋ฑ์ ์ฌ์ฉ๋ฉ๋๋ค.
int value = 10;
int * ptr; // intํ ๋ณ์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ ์ ์ธ
ptr = &value; // ptr์ ์ด์ value์ ์ฃผ์๋ฅผ ์ ์ฅ
๊ทธ๋์ int * ptr;
์ ์๋ฏธ๋, ์ฃผ์๋ฅผ ์ ์ฅํ๋ ๋ณ์ ptr
๋ฅผ ์ ์ธํ๋ค๋ ๊ฒ์
๋๋ค.
์์ ๋์ผํ ์ญํ ์ ์ฝ๋๊ฐ ์๋์ ๊ฐ์ต๋๋ค.
int value = 10;
int * ptr = &value; // ์ ์ธ๊ณผ ๋์์ value์ ์ฃผ์๋ฅผ ์ ์ฅ
1.1. ๋ฐฐ์ด์ ํฌ์ธํฐ
๊ฐ๋ น ์๋์ ๊ฐ์ 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] = arr;
/* "3๊ฐ์ int๋ก ๊ตฌ์ฑ๋ ๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ"๋ฅผ ์ ์ธ, arr์ ๋งจ ์ ์ฃผ์๋ฅผ ๋์
.
์ฆ,
โ p์ ํ์
์ "ํฌ์ธํฐ"
โ *p์ ํ์
์ "int[3]"
โ p[i]๋ i๋ฒ์งธ ํ(๋ฐฐ์ด)
โ p[i][j]๋ ๊ทธ ํ์ j๋ฒ์งธ ์์
*/
์ถ๊ฐ๋ก, ์ ์ ์ธ&๋์ ๋ฌธ์ ์๋์ ๊ฐ์ด ๋ถํดํ ์ ์์ต๋๋ค.
int (*p)[3];
p = arr;
2. ์ญ์ฐธ์กฐ ์ฐ์ฐ์๋ก์์ *
์ฌ๊ธฐ์์ *
๋ ์ญ์ฐธ์กฐ ์ฐ์ฐ์(dereference operator)์
๋๋ค. ํด๋น ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์๋ก ์ ๊ทผํ์ฌ, ๊ทธ ์ฃผ์์ ๋ ๊ฐ์ ์ฝ๊ฑฐ๋ ์์ ํ๋ผ๋ ์๋ฏธ์
๋๋ค.
int value = 10;
int * ptr = &value; // ptr์ value์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํด
*ptr = 20; // ptr์ด ๊ฐ๋ฆฌํค๋ ์ฃผ์์ ๊ฐ์ 20์ผ๋ก ๋ณ๊ฒฝ
printf("value: %d\n", value); // value: 20
์ * ptr = 20
์์ ๋ณด์๋ค์ํผ, ์ญ์ฐธ์กฐ ์ฐ์ฐ์๋ก์์ *์ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ์์น์ ์ค์ ๊ฐ์ ์ ๊ทผ/์์ ํ๋ ์ญํ ์ ํฉ๋๋ค.
๊ทธ๋ผ, ๋ง์ฝ int * ptr = 20;
๋ผ๋ ๋ฌธ์ฅ์ด ์๋ค๋ฉด, ์ด๋จ๊น์? ์ด๋ int*
๋ผ๋ ์๋ฃํ์ ๊ฐ์ง ptr
๋ฅผ ์ ์ธํ์ฌ ๊ทธ ๋ณ์์ 0x0000000000000014
(x86-64 ๊ธฐ์ค)๋ผ๋ ๊ฐ์ ๋ฃ์ผ๋ผ๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค. ์ฐ๋ฆฌ๊ฐ C ์ฝ๋๋ฅผ ์ง๋ฉด์ 0x0000000000000014
๋ผ๋ ์ ํํ ๋ฉ๋ชจ๋ฆฌ ์์น์ ๊ฐ์ผ ํ ์ผ์ด ์์๊น์? ์๋ฒ ๋๋๋ ๋ณด์์ชฝ์ด ์๋๊ณ ์์ผ 99.9%๋ ์๋ชป ์์ฑํ ์ฝ๋์ผ ๊ฒ์
๋๋ค.
์ฃผ์๊ฐ์ ์ง์ ๋์
ํด์ ์ง์ง๋ก ๋์๊ฐ๋ ์์์
๋๋ค. ์ด ์ฝ๋์์ root
๋ 0x3000
๋ผ๋ ์ฃผ์๊ฐ์ ๋ด๊ฒ ๋ฉ๋๋ค. ์ค๊ฐ์ ๋ญ๊ฐ ์ด์ํ ๊ฒ ๋ณด์ด์ง๋ง ์์ฌํ์ธ์. MS-DOS๋ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ/๋ณดํธ ๊ฐ๋
์ด "์์" ์์ผ๋ฏ๋ก Segmentation Fault ๊ฐ์ ๊ฑด ๋์ง ์์ผ๋๊น์. ๊ทธ๋ฅ ์ด์ฉ๋ค OS๊ฐ ์ฃฝ์ ๋ฟ์
๋๋ค.
3. ์ฃผ์๊ฐ์ ๊ตฌํ๋ ์ฐ์ฐ์ &
์ด๊ฑด ๊ทธ๋ฅ ํธํ๊ฒ ์ดํดํ๋ฉด ๋ฉ๋๋ค. ์ด๋ค ๋ณ์์ ์ฃผ์๊ฐ์ ๋ฐ์์ค๋ ์ฐ์ฐ์์ ๋๋ค.
int value = 10;
printf("value์ ์ฃผ์: %p\n", &value); // value์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์ ์ถ๋ ฅ
์ฌ๊ธฐ์ &value
๋ value
๋ผ๋ ๋ณ์๊ฐ ๋ฉ๋ชจ๋ฆฌ์์ ์์นํ ์ฃผ์๋ฅผ ์๋ฏธํฉ๋๋ค.
์ํ!
์ด์ ์ฒ์์ ๋ณด์ฌ๋๋ ธ๋ C ์ฝ๋๋ฅผ ๋ค์ ๋ด ์๋ค.
void main() {
int value = 123;
int * ptr1 = &value;
printf("*ptr1: %d\n", *ptr1); // ์ถ๋ ฅ ๊ฒฐ๊ณผ 123
*ptr1 = 456;
printf("*ptr1: %d\n", *ptr1); // ์ถ๋ ฅ ๊ฒฐ๊ณผ 456
}
์ ํฌ๋ ๋ ์ด์ ํท๊ฐ๋ฆฌ์ง ์์ต๋๋ค.
int * ptr1 = &value;
๋, "์ ์ํ ์ฃผ์๋ฅผ ์ ์ฅํ ํฌ์ธํฐ(ptr1
)๋ฅผ ์ ์ธํ๊ณ , ๊ทธ ์์value
์ ์ฃผ์๋ฅผ ๋ฃ์ผ๋ผ"๋ ๋ป์ ๋๋ค. ์ฌ๊ธฐ์*
๋ ์๋ฃํ์ผ๋ก์์ ๊ธฐํธ์ด๊ณ (int*, char*, float* ๋ฑ),&value
์ &๋ ์ฃผ์ ์ฐ์ฐ์(์ฃผ์๋ฅผ ๊ตฌํจ)์ ๋๋ค.- ๊ทธ ๋ค์ ์ค
*ptr1 = 456;
์ "ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์์ ์ง์ ๊ฐ์, ๊ทธ ์๋ฆฌ์ 456์ ์ ์ฅํ๋ผ"๋ ์๋ฏธ์ ๋๋ค. ์ฌ๊ธฐ์*
๋ ์ญ์ฐธ์กฐ ์ฐ์ฐ์์ ๋๋ค.
์ฆ, ๊ฐ์ *ptr1
์ด ๋ณด์ฌ๋, ๋ฌธ๋งฅ์ ๋ฐ๋ผ ๊ทธ *์ ์ญํ ์ด ๋ฌ๋ผ์ง๋ ๊ฒ์
๋๋ค.
๋ฌธ์ฅ | ์๋ฏธ |
---|---|
int * ptr1; |
ptr1 ์ int ํ์ ๊ฐ๋ฆฌํค๋(=ํฌ์ธํฐ) ๋ณ์์ด๋ค (ํฌ์ธํฐ ๋ณ์ ์ ์ธ) |
ptr1 = &value; |
ptr1 ์ด๋ผ๋ ๋ณ์์ value ์ ์ฃผ์๊ฐ์ ๋ด์ผ๋ผ (์ฃผ์๊ฐ + ๋์
) |
* ptr1 = 456; |
ptr1 ์ด ๊ฐ๋ฆฌํค๋ ์ฃผ์์ ๊ฐ์ 456์ ๋ด์ผ๋ผ (์ญ์ฐธ์กฐ + ๋์
) |
int * ptr1 = &value; |
ํฌ์ธํฐ ๋ณ์ ptr1 ์ ์ ์ธ, ๊ทธ๋ฆฌ๊ณ value ์ ์ฃผ์๊ฐ์ ๋ด์ผ๋ผ (์ ์ธ + ์ฃผ์๊ฐ + ๋์
) |
๊ฒฐ๊ตญ ์ค์ํ ๊ฑด ๋ฌธ๋งฅ์ ๋๋ค.
- ๋ณ์๋ฅผ ์ ์ธํ ๋์
*
๋ ํฌ์ธํฐํ์ ์๋ฏธํ๋ ์๋ฃํ ๋ฌธ๋ฒ - ๊ฐ์ ์ฝ๊ฑฐ๋ ์ธ ๋์
*
๋ ์ญ์ฐธ์กฐ ์ฐ์ฐ์ &
๋ ๋ณ์์ ์ฃผ์๋ฅผ ๊ฐ์ ธ์ค๋ ์ฃผ์ ์ฐ์ฐ์
ํนํ ์ ๋์ ๊ธฐํธ๋ ๊ฐ์๋ ์์ดํ ๋ฌธ๋ฒ์ ์๋ฏธ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ํฌ์ธํฐ๊ฐ ํท๊ฐ๋ ธ๋ ์ด์ ์ค ํ๋๋, ๋ฐ๋ก ๊ฐ์ ๊ธฐํธ(*
)๊ฐ ์์น์ ๋ฌธ๋งฅ์ ๋ฐ๋ผ ์ ํ ๋ค๋ฅธ ์ผ์ ํ๊ธฐ ๋๋ฌธ์ด์๋ ๊ฒ๋๋ค.
์ด์ ์ฌ๋ฌ๋ถ์ ํฌ์ธํฐ ๋ฌธ๋ฒ ์ ๊ธฐํธ๋ค์ ์๋ฏธ๋ฅผ ๋ถ๋ช ํ ๊ตฌ๋ถํ ์ ์๊ฒ ๋์์ต๋๋ค.
'IT > ์ปดํจํ ์ ์ฌ๊ณ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ ๋-๋ธ๋ ํธ๋ฆฌ (Red-Black Tree) (1) | 2025.04.18 |
---|---|
C์ธ์ด์ ํฌ์ธํฐ (๊ธฐ์ด) (0) | 2025.04.17 |
C์ธ์ด์ ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ (0) | 2025.04.17 |
C์ธ์ด์ ๋ค์ค ํฌ์ธํฐ (0) | 2025.04.13 |
์ด๋ถ ํ์๊ณผ Python์ bisect_left (0) | 2025.03.27 |
Python ์ปดํ๋ฆฌํจ์ ๋ฐ ํํ์ ์ ๋ฆฌ (0) | 2025.03.27 |
[์คํฌ๋ฉ] CS:APP ๋นํธ์ฐ์ฐ ๊ณผ์ bits.c ๋ต์ (0) | 2016.11.06 |
์๋ ํ์ธ์.
ํฌ์คํ ์ด ์ข์๋ค๋ฉด "์ข์์โค๏ธ" ๋๋ "๊ตฌ๋ ๐๐ป" ํด์ฃผ์ธ์!