ํฐ์คํ ๋ฆฌ ๋ทฐ
๐ ํฌ์ธํฐ์ ํฌ์ธํฐ
ํฌ์ธํฐ์ ํฌ์ธํฐ๋ ํฌ์ธํฐ ๋ณ์๋ฅผ ๊ฐ๋ฅดํค๋ ๋ ๋ค๋ฅธ ํฌ์ธํฐ ๋ณ์๋ฅผ ๋ปํ๋ ๊ฒ์ผ๋ก์ ํํ '์ด์ค ํฌ์ธํฐ' ๋๋ '๋๋ธ ํฌ์ธํฐ'๋ผ๊ณ ๋ถ๋ฅด๋ฉฐ, ํฌ์ธํฐ ๋ณ์์ ์ ์ธ์ ์ฌ์ฉ๋๋ * ์ฐ์ฐ์๋ฅผ ๋ ๊ฐ ์ด์ด์ ์ ์ธํ๋ค.
int **ptr = NULL; // ์ด๋ฐ ์์ผ๋ก *๋ฅผ ์ฐ๋ฌ์ ๋๊ฐ ์ฌ์ฉ !
๊ธฐ๋ณธ ์์
#include <stdio.h>
int main()
{
double num = 3.14;
double* ptr = # // num์ ์ฃผ์ ๊ฐ์ ์ ์ฅํ๋ ๋ณ์ ptr ์ ์ธ
double** dptr = &ptr; // ptr์ ์ฃผ์ ๊ฐ์ ์ ์ฅํ๋ ๋ณ์ dptr ์ ์ธ
double* ptr2;
printf("%9p %9p \n", ptr, *dptr); // *dptr์ ptr์ ์๋ฏธํ๋ ๋์ผํ ์ถ๋ ฅ๊ฐ
printf("%9g %9g \n", num, **dptr); // **dptr์ num์ ์๋ฏธํ๋ ๋์ผํ ์ถ๋ ฅ ๊ฐ
ptr2 = *dptr; //ptr2 = ptr๊ณผ ๊ฐ์ ๋ฌธ์ฅ
*ptr2 = 10.99; // ๋ณ์ num์ ๊ฐ์ 10.99๋ก ๋ณ๊ฒฝํ๊ณ ์๋ค
printf("%9g %9g \n", num, **dptr); // ๋ณ๊ฒฝ๋ num์ ๊ฐ์ ํฌ์ธํฐ ๋ณ์ dptr๊ณผ num์ ์ด์ฉํด์ ํ์ธ
return 0;
}
RESULT:
๐ ํฌ์ธํฐ ๋ณ์ ๋์์ Call-by-reference
๋ ์ฑ๊ธ ํฌ์ธํฐ ๋ณ์์ ์ ์ฅ๋ ๊ฐ์ ์๋ก ๋ฐ๊ฟ์ ์ ์ฅํ๋ ํจ์๋ฅผ ์ ์ํด๋ณด์. ์ฆ, ํฌ์ธํฐ ๋ณ์์ ์ฐธ์กฐ๊ด๊ณ๋ฅผ ๋ฐ๊ฟ์ฃผ๋ ํจ์๋ฅผ ์ ์ํ๋ ๊ฒ์ด๋ค.
#include <stdio.h>
void SwapIntPtr(int* p1, int* p2)
{
int* temp = p1;
p1 = p2;
p2 = temp;
} // int * p1 ๊ณผ int *p2์ ๊ฐ์ ๋ฐ๊ฟ๋ฒ๋ฆฌ๋ ํจ์
int main()
{
int num1 = 10, num2 = 20;
int* ptr1, * ptr2;
ptr1 = &num1, ptr2 = &num2;
printf("*ptr1,*ptr2: %d %d \n", *ptr1, *ptr2);
SwapIntPtr(ptr1, ptr2);
printf("*ptr1,*ptr2: %d %d \n", *ptr1, *ptr2);
return 0;
}
RESULT:
๊ฒฐ๊ณผ๊ฐ์ด ๋ฐ๋์ง ์๋ ๋ชจ์ต์ ํ์ธํ ์ ์๋ค. ์๋ํ๋ฉด p1์ ptr1๊ณผ ๋ณ๊ฐ์ด๊ณ p2๋ ptr2์ ๋ณ๊ฐ์ด๊ธฐ ๋๋ฌธ์ด๋ค. ์ฆ, p1๊ณผ p2์ ์ ์ฅ๋ ๊ฐ์ ๋ฐ๋์ง๋ง ์ด๋ ptr1๊ณผ ptr2์๋ ๋ณ๊ฐ์ ๋ณ์์ด๊ธฐ ๋๋ฌธ์ ptr1์ ์ฌ์ ํ num1์ ์ฃผ์ ๊ฐ์, ptr2๋ ์ฌ์ ํ num2์ ์ฃผ์ ๊ฐ์ ์ ์ฅํ๋ ์ํ๊ฐ ๋๋ค.
ptr1๊ณผ ptr2๊ฐ ๊ฐ๋ฅดํค๋ ๋์์ ๋ฐ๊พธ๊ธฐ ์ํด์๋ ํจ์ ๋ด์์ ํฌ์ธํฐ ๋ณ์ ptr1๊ณผ ptr2์ ์ง์ ์ ๊ทผ์ด ๊ฐ๋ฅํด์ผ ํ๋ค. ์ด๋ฅผ ์ํด์๋ int ํ ๋๋ธ ํฌ์ธํฐ๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ ์ธ๋์ด์ผ ํ๋ค.
#include <stdio.h>
void SwapIntPtr(int** dp1, int** dp2)
{
int* temp = *dp1;
*dp1 = *dp2;
*dp2 = temp;
}
int main()
{
int num1 = 10, num2 = 20;
int* ptr1, * ptr2;
ptr1 = &num1, ptr2 = &num2;
printf("*ptr1,*ptr2: %d %d \n", *ptr1, *ptr2);
SwapIntPtr(&ptr1, &ptr2);
printf("*ptr1, *ptr2: %d %d \n", *ptr1, *ptr2);
return 0;
}
RESULT:
[์ด์คํฌ์ธํฐ ๋ณ์์ ํ์ฉ]
๐ ์์ 1) ๐ง
๋ค์๊ณผ ๊ฐ์ด ๋ ๊ฐ์ ํฌ์ธํฐ ๋ณ์์ ๊ธธ์ด๊ฐ 5์ธ intํ ๋ฐฐ์ด์ ์ ์ธํ๋ค.
int *maxPtr;
int *minPtr;
int arr[5];
๊ทธ๋ฆฌ๊ณ MaxAndMin์ด๋ ์ด๋ฆ์ ํจ์๋ฅผ ์ ์ํ๊ณ ์ด๋ฅผ ํธ์ถํ๋ฉด์ ์์ ๋ฐฐ์ด๊ณผ ๋ ํฌ์ธํฐ ๋ณ์์ ๋ํ ์ ๋ณด๋ฅผ ์ ๋ฌํ์. ์ด๋ ํ ์ ๋ณด๋ฅผ ์ด๋ป๊ฒ ์ ๋ฌํ ์ง๋ ์ฌ๋ฌ๋ถ์ด ๊ฒฐ์ ํ ๋ชซ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ํจ์ํธ์ถ์ด ์๋ฃ๋๋ฉด, ํฌ์ธํฐ ๋ณ์ maxPtr์๋ ๊ฐ์ฅ ํฐ ๊ฐ์ด ์ ์ฅ๋ ๋ฐฐ์ด์์์ ์ฃผ์ ๊ฐ์ด, minPtr์๋ ๊ฐ์ฅ ์์ ๊ฐ์ด ์ ์ฅ๋ ๋ฐฐ์ด์์์ ์ฃผ์ ๊ฐ์ด ์ ์ฅ๋์ด์ผ ํ๋ค.
๐คฆโ๏ธ ์๊ฐ ๊ณผ์
1. ๋จผ์ MaxAndMin ํจ์์ ์ญํ ์ ์ ํด์ค๋ค. ๋ฐฐ์ด์ ์๋ฅผ ๋น๊ตํ์ฌ max ๊ฐ๊ณผ min ๊ฐ์ ์ฐพ์์ฃผ๋ ํจ์๋ก ์ค์ ํ์๋ค. ๋น๊ต๋ฅผ ํด์ผํ๋ for๋ฌธ์ ์ด์ฉํ์ฌ if๋ฌธ์ ํตํด ๋งจ ์ฒ์ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ arr[0]์ผ๋ก ์ค์ ํ์ฌ ๋น๊ตํด์ค๋ค. ์ฌ๊ธฐ์ ์ค์ํ ์ ์ ๊ฐ์ ๋ฐ๊พธ๊ธฐ ์ํด์๋ ์ง์ ์ ๊ทผ์ด ๊ฐ๋ฅํด์ผํ๋ int ํ ๋๋ธํฌ์ธํฐ๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ ์ธ๋์ด์ผ ํ๋ ์ ์ด๋ค.
2. main ํจ์์์ scanf ๋ฅผ ์ด์ฉํ์ฌ ์ฌ์ฉ์์๊ฒ ๋ฐฐ์ด์ ์๋ฅผ ์ ๋ ฅ๋ฐ๋๋ก ํ๊ฒ ๋ค.
๋ต์:
#include <stdio.h>
void MaxAndMin(int* arr, int size, int** mxPtr, int** mnPtr)
{
int* max, * min;
int i;
max = min = &arr[0];
for (i = 0; i < size; i++)
{
if (*max < arr[i])
max = &arr[i];
if (*min > arr[i])
min = &arr[i];
}
*mxPtr = max;
*mnPtr = min;
}
int main()
{
int* maxPtr;
int* minPtr;
int arr[5];
int i;
for (i = 0; i < 5; i++)
{
printf("์ ์ ์
๋ ฅ %d : ", i + 1);
scanf("%d", &arr[i]);
}
MaxAndMin(arr, sizeof(arr) / sizeof(int), &maxPtr, &minPtr);
printf("์ต๋: %d, ์ต์: %d \n", *maxPtr, *minPtr);
return 0;
}
RESULT:
โ ๋ณด์ถฉํ ๋ถ๋ถ
1. ๋ฏธ๋ฆฌ ๊ฐ ํจ์์ ์ญํ ๊ณผ ๋ชฉํ๋ฅผ ๋ช ์ํด๋๊ณ ์ฝ๋ ์ง๊ธฐ
'์ธ์ด > C' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C์ธ์ด] 1์ฐจ์ ๋ฐฐ์ด์ด๋ฆ์ ํฌ์ธํฐ ํ๊ณผ 2์ฐจ์ ๋ฐฐ์ด์ด๋ฆ์ ํฌ์ธํฐ ํ (0) | 2023.03.08 |
---|---|
[C์ธ์ด] ํจ์์ ์ธ์๋ก ๋ฐฐ์ด ์ ๋ฌํ๊ธฐ (0) | 2023.03.06 |
[C์ธ์ด] ๋ค์ฐจ์ ๋ฐฐ์ด (0) | 2023.02.19 |
[C์ธ์ด] call-by-value VS call-by-reference (0) | 2023.02.17 |
[C์ธ์ด] ํฌ์ธํฐ์ ๋ฐฐ์ด (1) (0) | 2023.02.16 |