What is pointer
ํฌ์ธํฐ๋ ๋จผ์ ์๋ฃํ์ผ๋ก ์ ์ธํ ์ ์๋ค. ๊ฐ๊ฐ์ ์๋ฃํ์ ๋ํดย *
ย ๋ฅผ ๋ฌ๊ฒ ๋๋ฉด ์ ์ธํ ์ ์์ผ๋ฉฐ.
์ด ์๋ฏธ๋ฅผ ๋ง๋ก ํ์
ํ๋ ๊ฒ์ด ์ค์ํ๋ฐ, int* p
ย ์ ๊ฐ์ ๊ฒฝ์ฐ, ํน์ ์๋ฃํ์ด int์ธ ๋ณ์์ ์ฃผ์๋ฅผ ๋ฐ์ ์ ์๋ ํฌ์ธํฐ ๋ณ์ p๋ฅผ ์์ฑํด๋ผ ๋ก ์๊ฐ ํ ์ ์๋ค.
char* c
ย ์ ๊ฐ์ ๊ฒฝ์ฐ, ํน์ ์๋ฃํ์ด char์ธ ๋ณ์์ ์ฃผ์๋ฅผ ๋ฐ์ ์ ์๋ ํฌ์ธํฐ ๋ณ์ c๋ฅผ ์์ฑํด๋ผ ๋ก ํ๋จํ๋ฉด ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ์ด๋ค ์์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋น์ด ๋ ๊น?
#include <iostream>
using namespace std;
int main(){
int x;
x = 4;
int* p;
p = &x;
cout << p << endl;
cout << a << ", " << *p << endl;
return 0;
}
์ด๋ ๊ฒ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์๋ฆฌ์ก๊ฒ ๋๋ค. ์ด๋ p์ ์ฃผ์์ ์๋ ๊ฐ์ผ๋ก๊ฐ์, ๊ทธ ๊ฐ์ ์ถ๋ ฅํ๊ฒ ํ๋ ๋ฐฉ๋ฒ์ ํฌ์ธํฐ ๋ณ์ p์ย *
ย ๋ฅผ ๋ฌ๋ฉด ๊ฐ๋ฅํ๋ค. ํด๋น ์ฃผ์๋กย ์ ํย ๋ฅผ ํ๋ค๊ณ ์ดํดํ๋ฉด ์ง๊ด์ ์ด๋ค.
Output
0x04
4, 4
์ด๊ฒ์ ๊ทธ๋ฆผ์ผ๋ก ์ข๋ ์ง๊ด์ ์ผ๋ก ์ดํดํด๋ณด์.
์ฌ๊ธฐ์ ๊ฐ์ฅ ํต์ฌ์ ์ผ๋ก ์๊ฐํด์ผ ํ๋ ๋ถ๋ถ์, ํฌ์ธํฐ ๋ณ์๋ฅผ ์ ์ธํ ๋ค์ ๊ผญ ์ด ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์๋ฅผ ํ ๋นํด์ฃผ์ด์ผ ํ๋ค๋ ๊ฒ์ด๋ค.
PassingByAddress
์ด์ ๊น์ง ํจ์ํธ์ถ์ ๊ดํด Callbyvalue, Callbyreference์ ๊ฐ์ ๊ฒ์ ๋ฐฐ์ ๋ค.
๊ทธ๋ฐ๋ฐ ์ด์ ํฌ์ธํฐ๋ฅผ ๋ฐฐ์ฐ๊ฒ ๋๋ฉด, ํจ์์ ์ธ์๋ฅผ ํฌ์ธํฐ ๋ณ์๋ก ์ ์ธํ๊ณ , ๊ฐ์ ๋๊ธธ ๋ย ์ฃผ์ย ๋ฅผ ๋๊ฒจ์ค ์ ์๋ค.
ํจ์๋ฅผ ํธ์ถํ๊ณ ๋๋ฉด, ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ฅ๋ ๋ ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝํ๋ย Swapย ํจ์๋ฅผ ๋ง๋ค์ด๋ณด์.
#include <iostream>
using namespace std;
void swap(int* var1, int* var2){
int temp = *var1 // var1์ ์ฃผ์๋ก ์ ํํ ๊ฐ์ temp์ ์ ์ฅํด๋ผ
*var1 = *var2; // var1์ ์ฃผ์๋ก ์ ํํ ๊ฐ์ var2์ ์ฃผ์๋ก ์ ํํ ๊ฐ์ ํ ๋นํด๋ผ
*var2 = temp; // var2์ ์ฃผ์๋ก ์ ํํ ๊ฐ์ temp์ ๊ฐ์ ๋ฃ์ด๋ผ.
}
int main(){
int a = 4, b = 5;
cout << a << "," << b << endl;
swap(&a,&b);
cout << a << ", " << b << endl;
return 0;
}
Output
4, 5
5, 4
Function Pointer
ํจ์ ํฌ์ธํฐ? ํจ์ ์ญ์ ํฌ์ธํฐ๋ก ๊ตฌ์ฑ๋์ด ์๋ค๋ ์ฌ์ค์ ๋ชจ๋ฅธ๋ค๋ฉด ๋นํฉ์ค๋ฌ์ธ ์ ์๋ค.
์ฐ๋ฆฌ๊ฐ ํจ์๋ฅผ ํธ์ถํ๋ค๋ ๊ฒ์, ์ปดํ์ผ ์ดํ ํน์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์๋์ด ์๋ ํ์์ ์์น๋ก ๊ฐ์ ์ฝ์ด์ค๋ผ๋ ๋ป์ด๋ค.
๊ทธ๋ฌ๊ธฐ ์ํด์๋ ํจ์ํธ์ถ์ ํ์ ๋, ๊ทธ ์์น๋ก ๊ฐ์ผํ๋ค๋ ์๋ฏธ์ด๊ณ , ๊ฒฐ๊ตญ์ ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ์๋ฅผ ์์์ผ ํ๋ค๋ ๊ฒฐ๋ก ์ ์ป์ ์ ์๋ค.
๋ฐ๋ผ์ ์ฐ๋ฆฌ๊ฐ ํจ์์ ์ด๋ฆ์ ์ค์ ํ๊ณ ๋๋ฉด, ์ด ํจ์์ ์ด๋ฆ์ ํฌ์ธํฐ์ด๋ค.
์ฆ, ์ปดํ์ผ ์ดํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์์ฑ๋ ์ผ๋ จ์ ์์ ํ์๊ฐ ์ ํ ๊ณณ์ ์์ ์์น ์ฃผ์๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
์ด ๊ตฌ์กฐ๋ฅผ ์๊ณ ์๋ค๋ฉด ์ฐ๋ฆฌ๋ ํน์ ๋ค๋ฅธ ํจ์๋ฅผ ์งค๋, ํ๋ผ๋ฏธํฐ๋ก ์ด ํจ์์ ์์ ์ฃผ์๋ฅผ ๋ฃ์ด ๋ ๊ณ ์ฐจ์์ ์ธ ํ๋ก๊ทธ๋๋ฐ์ ๊ฐ๋ฅํ๊ฒ ํ ์ ์๋ค.
ํจ์ ํฌ์ธํฐ ์ฌ์ฉ๋ฒ
ํจ์๊ฐ_๋ฐํํ๋_์๋ฃํ (*ํจ์ํฌ์ธํฐ๋ก_์ฌ์ฉํ _๋ณ์_์ด๋ฆ)(์ธํํ๋ผ๋ฏธํฐ์_์๋ฃํ, ์ธํํ๋ผ๋ฏธํฐ์_์๋ฃํ, ...)
์์
#include <iostream>
using namespace std;
int add(int a, int b){
return x + y;
}
int multiply(int a, int b){
return x*y;
}
int evaluate(int (*f)(int, int), int x, int y){
return f(x, y); // main ์ผ๋ก๋ถํฐ ํจ์์ ์์์ฃผ์๋ฅผ ํฌ์ธํฐ ๋ณ์ f๋ก ๋ฐ๊ณ ,
// ๊ทธ ํจ์์ ์ธํ์ผ๋ก x, y๋ฅผ ์ค ๊ฐ์ ๋ฐํํด๋ผ.
}
int main(){
cout << add(2, 3) << endl;
cout << multiply(2, 3) << endl;
cout << evaluate(&add, 2, 3) << endl;
cout << evaluate(&multiply, 2, 3) << endl;
}
Output
5
6
5
6