C ์ธ์ด - ํฌ์ธํฐ ์ด์ ๋ฆฌ (Pointer) | void , ์ด์ค ํฌ์ธํฐ , ์ญ์ฐธ์กฐ
- -
*ํฌ์ธํฐ (pointer)
C์์ ๊ฐ์ ์ ์ฅํ ๋ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ค. ์ด๋ ์ด ๋ณ์๋ ์ปดํจํฐ์ ๋ฉ๋ชจ๋ฆฌ์ ์์ฑ๋๋๋ฐ, ์ด ๋ฉ๋ชจ๋ฆฌ์ ํน์ ์ฅ์์ ์ ์ฅ๊ณต๊ฐ์ ํ๋ณดํด๋๊ณ ์ ์ฅ, ๋ก๋๋ฅผ ํ๋ ๋ฐฉ์์ด๋ค.
๋ฐ๋ผ์ ๋ณ์์ ์ ๊ทผํ ๋๋, 1. ๋ณ์๋ช ์ผ๋ก ์ ๊ทผํ๋ ๋ฐฉ๋ฒ. 2. ๋ฉ๋ชจ๋ฆฌ์ ํน์ ์ฅ์๊ฐ(๋ฉ๋ชจ๋ฆฌ ์ฃผ์)๋ก ์ ๊ทผํ๋ ๋ฐฉ๋ฒ์ด ์๋ค.
์ด ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ์ ๊ฐ๋๊ฒ์ ํฌ์ธํฐ ๋ณ์ ๋ผ๊ณ ํ๋ค.
*ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ ์ด์
ํฌ์ธํฐ๋ ์ปดํจํฐ ์์คํ ์ ํน์ ๋ฉ๋ชจ๋ฆฌ์ ๋ฐ๋ก ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค. ๊ทธ๋ฆฌ๊ณ ๊ตฌ์กฐํ๋ ์๋ฃ๋ฅผ ๋ง๋ค์ด ํจ์จ์ ์ธ ์ด์์ด ๊ฐ๋ฅํ๋ฉฐ, ๋ฐฐ์ด๊ณผ ๊ตฌ์กฐ์ฒด๋ฑ์ ์๋ฃ ๊ตฌ์กฐํจ์์ ์ ๊ทผ์ด ์ฉ์ดํ๋ค.
* ๋ฉ๋ชจ๋ฆฌ ์ฃผ์ | ์ฃผ์์ฐ์ฐ์ & | ์์์ง์ ์ %p
64๋นํธ ์ปดํจํฐ์์๋ 16์ง์ 16์๋ฆฌ์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๊ฐ์ง๋ค.
- 0x0000000000000000 ~ 0xFFFFFFFFFFFFFFFF
๊ทธ๋ฆฌ๊ณ C์์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ ์ ๊ทผํ๊ธฐ ์ํด์๋ ์ฃผ์์ฐ์ฐ์ & ๋ฅผ ์ฌ์ฉํ๋ค. ์ถ๋ ฅํ ๋ ์์ ์ง์ ์๋ %p์ด๋ค.
#include <stdio.h>
int main(){
int num1 = 2;
printf("%p", &num1);
}
์ถ๋ ฅ >>>>>> 0061FF1C
์ด๋ ์ถ๋ ฅ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ์, ์คํ ํ๊ฒฝ์ ๋ฐ๋ผ, ์ฌ์ฉ ์ปดํจํฐ์ ๋ฐ๋ผ ๊ณ์ํด์ ๋ฌ๋ผ์ง๋ค.
*ํฌ์ธํฐ ๋ณ์ ์ ์ธ | *(Asterisk, ์ ์คํฐ๋ฆฌ์คํฌ)
ํฌ์ธํฐ ๋ณ์๋ฅผ ์ ์ธํ๋ ค๋ฉด *(Asterisk, ์ ์คํฐ๋ฆฌ์คํฌ) ๋ฅผ ์ฌ์ฉํ๋ค. " *๋ ์ด ๋ณ์๊ฐ ํฌ์ธํฐ๋ค" ๋ผ๊ณ ์๋ ค์ฃผ๋ ์ญํ ์ ํ๋ค.
ํฌ์ธํฐ ์ ์ธํ๊ธฐ
int num1 = 12;
int *num1_pointer = &num1;
printf("%p", num1_pointer);
num1_pointer : num1์ ์ฃผ์๊ฐ์ด ๋ค์ด์๋ ํฌ์ธํธ ๋ณ์์ด๋ค.
num1_pointer๊ฐ ๊ฐ๊ณ ์๋ ์ฃผ์๊ฐ์ ๋ญ๊ฐ ๋ค์ด์๋์ง ํ์ธํ๋ ค๋ฉด ๋ค์ *๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
์ด๋ ์ฌ์ฉ๋๋ *๋ ์ญ์ฐธ์กฐ ์ฐ์ฐ์(๊ฐ์ ์ฐธ์กฐ ์ฐ์ฐ์)๋ผ๊ณ ํ๋ฉฐ, ์ ์ธํ ๋ ์ฌ์ฉ๋๋ *์๋ ๋ค๋ฅธ ์๋ฏธ๋ฅผ ๊ฐ๋๋ค.
์ฌ๊ธฐ์์ " *๋ ์ญ์ฐธ์กฐํ์ฌ ๊ฐ์ ๊ฐ์ ธ์ค๊ฒ ๋ค"๋ผ๋ ๋ป์ ๊ฐ์ง๋ค.
ํฌ์ธํฐ๋ ๋ณ์์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํจ๋ค. ๊ทธ๋ฆฌ๊ณ ์ญ์ฐธ์กฐ๋ ๊ทธ ์ฃผ์์ ์ ๊ทผํ์ฌ ๊ฐ์ ๊ฐ์ ธ์จ๋ค.
ํฌ์ธํฐ๋ฅผ ์ด์ฉํ์ฌ ๋ณ์์ ๊ฐ ์ถ๋ ฅํ๊ธฐ
#include <stdio.h>
int main(){
int num1 = 2;
int *pointer = &num1;
printf("%d\n", *pointer);
}
์ถ๋ ฅ >>>>> 2
ํฌ์ธํฐ๋ฅผ ์ด์ฉํ์ฌ ๋ณ์์ ๊ฐ ๋ฐ๊พธ๊ธฐ
#include <stdio.h>
int main(){
int num1 = 2;
int *num1_pointer = &num1;
*num1_pointer = 2000;
printf("%d", num1);
}
์ญ์ฐธ์กฐ ์ฐ์ฐ์๋ก ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ ์ ๊ทผํ์ฌ, 2๋ฅผ 2000์ผ๋ก ๋ฐ๊พธ์๋ค.
* ์๋ฃํ๊ณผ ํฌ์ธํฐ | ์๋ฃํ์ด ์ ํด์ง์ง ์์ void ํฌ์ธํฐ
- C ์ ์๋ ๋ชจ๋ ์๋ฃํ์ ํฌ์ธํฐ๋ก ๋ง๋ค ์ ์๋ค. ex ) long long *num1_pointer; float *num2_pointer;
- ์ ์ธํ๋ ์๋ฃํ์ ๋ฐ๋ผ ๋ฉ๋ชจ๋ฆฌ์ ์ ๊ทผํ๋ ๋ฐฉ์์ด ๋ค๋ฅด๋ค. ์๋๋ฉด ์๋ฃํ๋ง๋ค size๊ฐ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ (int 4๋ฐ์ดํธ, char 1๋ฐ์ดํธ...)
- ์๋ฃํ์ด ์ ํด์ง์ง ์์ ํฌ์ธํฐ๋ ์๋ค. ์ด๋ฅผ void ํฌ์ธํฐ๋ผ๊ณ ํ๋ค.
#include <stdio.h>
int main(){
int num1= 10;
char c1 = 'a';
int *num1_Ptr = &num1; // intํ ํฌ์ธํฐ
char *c1_Ptr = &c1; // charํ ํฌ์ธํฐ
void *ptr; // ์๋ฃํ์ด ์๋ void ํฌ์ธํฐ
// ์๋ฃํ์ด ์ ํด์ง์ง ์์๊ธฐ ๋๋ฌธ์, ์ด๋ ํ ์๋ฃํ์ ์ฃผ์๋ฅผ ๋ฃ์ด๋ ์๊ด์๋ค.
ptr = num1_Ptr;
ptr = c1_Ptr;
// ๋ํ ์๋ฃํ์ด ์ ํด์ง ํฌ์ธํฐ์ void ํฌ์ธํฐ๋ฅผ ์ ์ฅํด๋ ๋ฌธ์ ๊ฐ ์๋ค.
num1_Ptr = ptr;
c1_Ptr = ptr;
return 0;
}
void ํฌ์ธํฐ๋ ์๋ฃํ์ด ์ ํด์ง์ง ์์๋ค. ๋ฐ๋ผ์ ์๋์ ํน์ง์ด ์๋ค.
1) ์ด๋ค ์๋ฃํ์ผ๋ก ๋ ํฌ์ธํฐ๋ voidํฌ์ธํฐ์ ๋ฃ์ ์ ์๋ค.
2) voidํฌ์ธํฐ๋ฅผ ์ด๋ค ์๋ฃํ์ผ๋ก ๋ ํฌ์ธํฐ์๋ ๋ฃ์ ์ ์๋ค.
3) void ํฌ์ธํฐ๋ ์ญ์ฐธ์กฐ๋ฅผ ํ ์ ์๋ค. (์๋ฃํ์ด ์๊ธฐ ๋๋ฌธ์, ๊ฐ์ ๊ฐ์ ธ์ค๊ฑฐ๋, ์ ์ฅํ size๊ฐ ์ ํด์ง์ง ์์๊ธฐ ๋๋ฌธ์)
์ญ์ฐธ์กฐ๊ฐ ๋์ง ์์์๋ void ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๋ , ํจ์์์ ์ฌ๋ฌ์ข ๋ฅ์ ์๋ฃํ์ ๋ฐ์๋ค์ผ๋ , ํจ์์ ๋ฐํ ํฌ์ธํฐ๋ฅผ ์ฌ๋ฌ์ข ๋ฅ์ ์๋ฃํ์ผ๋ก ๋ ํฌ์ธํฐ์ ์ ์ฅํ ๋, ์๋ฃํ์ ์จ๊ธฐ๊ณ ์ถ์๋ ์ฌ์ฉํ๋ค.
*์์์ ํฌ์ธํฐ
ํฌ์ธํฐ์๋ const๋ฅผ ๋ถ์ฌ ์์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ฅผ ๋ง๋ค์์๋ค. ์ด๋ const์ ์์น์ ๋ฐ๋ผ์ ํน์ฑ์ด ๋ฌ๋ผ์ง๋ค.
1. ์์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ (pointer to constant)
const int num1 = 10;
const int *num1_pointer = &num1;
*num_pointer = 1300; >>>>>> ์ปดํ์ผ ์๋ฌ
๋ง์ง๋ง ์ค์์ ์ปดํ์ผ ์๋ฌ๊ฐ ๋๋ ์ด์ : ๋ณ์ num1์ด ์์์ธ๋ฐ ๊ฐ์ ๋ฐ๊พธ๋ ค ํ๊ธฐ ๋๋ฌธ์.
2. ํฌ์ธํฐ ์์ฒด๊ฐ ์์
int num1 = 10;
int num2 = 1;
int * const num1_pointer = &num1;
num1_pointer = &num2; >>>>>>์ปดํ์ผ ์๋ฌ
๋ง์ง๋ง ์ค์์ ์ปดํ์ผ ์๋ฌ๊ฐ ๋๋ ์ด์ : ํฌ์ธํฐ ์์ฒด๊ฐ ์์์ธ๋ฐ, ๋ค๋ฅธ ๋ณ์์ ์ฃผ์๊ฐ์ ๋ฃ์ผ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์
3. ์์๋ฅผ ๊ฐ๋ฆฌํค๋ฉด์, ํฌ์ธํฐ ์์ฒด๋ ์์
const int num1 = 10;
const int * const num1_pointer = &num1;
1๋ฒ๊ฒฝ์ฐ + 2๋ฒ๊ฒฝ์ฐ ์ด๊ธฐ ๋๋ฌธ์, ํฌ์ธํฐ์ ์ฃผ์๊ฐ๋ ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅํ๊ณ , ์ญ์ฐธ์กฐํ์ฌ ๋ณ์๊ฐ์ ๋ณ๊ฒฝํ๋๊ฒ๋ ๋ถ๊ฐ๋ฅํ๋ค.
* ํฌ์ธํฐ ์ฝ๋ ๋ฐฉ๋ฒ
๋ฌด์กฐ๊ฑด ์ญ์์ผ๋ก ์ฝ์ด์ฃผ๋ฉด ๋๋ค.
* ์ด์ค ํฌ์ธํฐ ( ํฌ์ธํฐ์ ํฌ์ธํฐ)
- ํฌ์ธํฐ๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ (์ด์ค ํฌ์ธํฐ)๋ *๋ฅผ ๋๋ฒ ์ฌ์ฉํ์ฌ ์ ์ธํ๋ค.
- ์ญ์ฐธ์กฐ๋๋ *๋ฅผ ๋๋ฒ ์ฌ์ฉํด์ผํ๋ค.
- ํฌ์ธํฐ์ ๋ฉ๋ชจ๋ฆฌ์ฃผ์๋ฅผ ์ ์ฅํ๊ธฐ ์ํด์๋ ์ด์ค ํฌ์ธํฐ์๋ง ์ ์ฅํด์ผ ํ๋ค.
- ์ด์ค ํฌ์ธํฐ๋ฟ ์๋๋ผ, 3์ค 4์ค ๊ทธ ์ด์๋ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
#include <stdio.h>
int main(){
int *pointer1;
int **pointer2;
int num = 10;
pointer1 = #
pointer2 = &pointer1;
printf("%d\n", num);
printf("%d\n", *pointer1);
printf("%d\n", **pointer2);
return 0;
}
์ถ๋ ฅ >>>>> 10 10 10
num์ ์ฃผ์๊ฐ์ pointer1๊ฐ ๊ฐ์ง๋ค. ๊ทธ๋ฆฌ๊ณ pointer1์ ์ฃผ์๊ฐ์ pointer2๊ฐ ๊ฐ์ง๋ค.
pointer2์ ์ฐธ์กฐ ๊ฒฝ๋ก : pointer1์ ์ฃผ์๊ฐ-> num1์ ์ฃผ์๊ฐ -> num1 (๊ฐ)
๋ฐ๋ผ์, num == *pointer1 == **pointer2 == 10 ์ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค.
'๐ฉโ๐ป C' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋น์ ์ด ์ข์ํ ๋งํ ์ฝํ ์ธ
-
C ์ธ์ด - ์ ์, ์ค์์ ์ค๋ฒํ๋ก์ฐ, ์ธ๋ํ๋ก์ฐ (overflow , underflow) 2020.10.17
-
C ์ธ์ด - ๋ฌธ์์ด ์ด์ ๋ฆฌ | ๋ฌธ์์ด ๊ด๋ จ ํจ์ , ๋ฒํผ (buffer) ํฌ์ธํฐ ๋ฌธ์์ด (pointer) , ์ ๋ ฅ๊ฐ ๋ฐ๊ธฐ (scanf , EOF ,strlen) 2020.03.04
-
C ์ธ์ด - ๋ฐฐ์ด (array ) , 2์ฐจ์ ๋ฐฐ์ด, ๋ฐฐ์ด์ ํฌ์ธํฐ (pointer) 2020.02.29
-
C์ธ์ด - ํจ์ , ์ฌ๊ท ํจ์ , (factorial) 2020.02.28
์์คํ ๊ณต๊ฐ ๊ฐ์ฌํฉ๋๋ค