[C++] ํฌ์ธํฐ์ ์ฐธ์กฐ์
๐ ํฌ์ธํฐ๋?
๋ฉ๋ชจ๋ฆฌ์ "์ฃผ์๊ฐ"์ ์ ์ฅํ๋ ๋ณ์
๋ณ์๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฉ๋ชจ๋ฆฌ์ ๊ณต๊ฐ์ด๋ผ๋ฉด, ํฌ์ธํฐ๋ ๊ทธ ๋ณ์๋ฅผ ๊ฐ๋ฆฌํค๋ ๋ณ์๋ผ๊ณ ํ ์ ์๋ค.
๋ณ์ ์์ *์ ๋ถ์ฌ์ ์ ์ธํ๋ค.
โถ ๊ทธ๋ ๋ค๋ฉด, ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ ์ด์ ?
๋ค๋ฅธ ํ๋ก๊ทธ๋จ์ด๋ ํ์ผ์์ ์ฐธ์กฐ ์, ๋ณต์ฌ๋ณธ์ด ์๋ ์ง์ง ํด๋น ๋ณ์์ ์ ๊ทผํ๊ธฐ ์ํจ.
์ฃผ์ ์ฐ์ฐ์ & : ๋ณ์์ ์ฃผ์๊ฐ ๋ฐํ ( = ์ฐ์ฐ์ ๋ค์ ์ฐ์. ๋ณ์ ์ด๋ฆ ๋ค์ ์ฌ์ฉ๋จ )
ํฌ์ธํฐ * : ๋ณ์์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํด (&๋ณ์๋ฅผ ํตํด ๋ณ์์ ์ฃผ์๋ฅผ ๊ฐ์ ธ์ฌ ์ ์์)
์ญ์ฐธ์กฐ * : ํฌ์ธํฐ ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ์ฃผ์์ ์๋ ๊ฐ์ ๊ฐ์ ธ์ด
int i๋ฅผ ํจ์์ ํ๋ผ๋ฏธํฐ๋ก ์คฌ์ ๋, ์ค์ i ์ ์ ๊ทผํ์ฌ ๊ฐ ๊ฐ์ ธ์ค์ง ์๊ณ , ๋ณต์ฌํ์ฌ ์ฐ์ฐํจ.
๋ฐ๋ผ์ ํฌ์ธํฐ๋ฅผ ์ด์ฉํด ๋ณ์์ ์ฃผ์์ ์ง์ ์ ๊ทผํ์ฌ ์ง์ง ํด๋น ๋ณ์์ ์ ๊ทผ
/* ์ฃผ์ ์ฐ์ฐ์ &์ ํฌ์ธํฐ์ ์ฐ์ */
int a = 5;
int* b = &a // b: a์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ
ํฌ์ธํฐ ํ์ ๋ณ์๋ ๋ณ์ ์์ฒด์ ๊ฐ์ ์์ ํ๋ค๊ณ ํ์ฌ ์๋ ๊ฐ๋ ์์ ๋์ง ์๋๋ค.
ํฌ์ธํฐ ํ์ ์ ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ณณ๊น์ง * ๋ฅผ ์ด์ฉํ์ฌ ์ญ์ฐธ์กฐ(dereference)ํ์ฌ์ผ ์๋ ๊ฐ์ด ์์ ๋๋ค.
/* ์์ */
int a = 7;
int* b = &a; // a์ ์ฃผ์๋ฅผ b์ ์ ์ฅ
b = 10; // a๋ฅผ ์ถ๋ ฅํ๋ฉด, ์ฌ์ ํ 7์ด๋ค. ์ฆ, b์ ๊ฐ์ ์์ ํ๋ค๊ณ ํ์ฌ a์ ๋ณํ x
int* b = a;
(*b) = 10; // a๋ฅผ ์ถ๋ ฅํ๋ฉด 10์ผ๋ก ๊ฐ์ด ๋ณํจ.
๐ ์ฐธ์กฐ์๋?
๋ณ์์ ๋ณ์นญ(alias)๊ณผ ๊ฐ์ ์กด์ฌ. ๋ณ์์ ๋ฉ๋ชจ๋ฆฌ ์์น๋ฅผ ์ง์ ์ฐธ์กฐ
ํฌ์ธํฐ์ ์ ์ฌํ์ง๋ง, NULL ๊ฐ์ ๊ฐ์ง ์ ์๊ณ , ์ ์ธ๊ณผ ๋์์ ์ฐธ์กฐํ ๋ณ์๋ฅผ ๋ฐ๋์ ์ง์ ํด์ผ ํ๋ค.
๋ํ, ํ ๋ฒ ๋ณ์๋ฅผ ์ฐธ์กฐํ๋ค๋ฉด, ์ดํ ๋ค๋ฅธ ๋ณ์๋ฅผ ์ฐธ์กฐํ๋ ๊ฒ์ผ๋ก ๋ฐ๊ฟ ์ ์๋ค.
โถ ๊ทธ๋ ๋ค๋ฉด, ์ฐธ์กฐ์๋ฅผ ์ฌ์ฉํ๋ ์ด์ ?
ํจ์์ ํ์ ๋งค๊ฐ๋ณ์ ๋ฑ์ ์ฌ์ฉํ์ฌ ๋ณต์ฌ๋ณธ์ด ์๋, ์๋ณธ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๊ณ ์์ ํ๊ธฐ ์ํจ
๋ณต์ฌ๋ณธ์ ๋ง๋ค์ด์ ์๊ธฐ๋ ์ค๋ฒํค๋ ๋ํ ๋ฐฉ์งํ ์ ์๋ค.
์ฆ, ์ฐธ์กฐ ๋ณ์ = ํด๋น ๋ณ์์ ์ฃผ์๋ฅผ ์ง์ ๊ฐ๋ฆฌํค๋ ๋ค๋ฅธ ์ด๋ฆ์ ๋ณ์
์ฐธ์กฐ ์ฐ์ฐ์ & : ์ผ์ชฝ์ ๋ณ์๊ฐ ์ค๋ฅธ์ชฝ์ ๋ณ๋ช ์์ ๋ํ๋. ( = ์ฐ์ฐ์ ์ผ์ชฝ์ ์ฐ์ )
์๋ณธ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๊ณ ์์ ํ๊ธฐ ๋๋ฌธ์, ์ฐธ์กฐ ๋ณ์์ ๊ฐ์ ์์ ํ๋ฉด ์๋ณธ ๋ณ์์ ๊ฐ ๋ํ ๋ณํ๋ค.
int a = 7;
int& b = a; // b๋ a์ ๋ณ๋ช
์ด๋ผ ํ ์ ์๋ค.
b = 5; // a๋ฅผ ์ถ๋ ฅํด๋ณด๋ฉด a๋ 5๊ฐ ๋์ด, b๋ฅผ ์์ ํ๋ฉด a๋ ์์ ๋จ์ ์ ์ ์๋ค.
๋ณ๋ช ๊ณผ ๊ฐ์ ์กด์ฌ์ด๊ธฐ ๋๋ฌธ์ ๋ฉ๋ชจ๋ฆฌ ์์ ๊ณต๊ฐ์ด ํ ๋น๋์ง ์๋๋ค.
โถ ํจ์์ ๋ํ ์ฐธ์กฐ์
#include <iostream>
using namespace std;
int change_val(int &p) { // int& p = number์ ๋ง์ฐฌ๊ฐ์ง
p = 3;
return 0;
}
int main() {
int number = 5;
cout << number << endl; // ์ถ๋ ฅ ๊ฒฐ๊ณผ number = 5
change_val(number);
cout << number << endl; // ์ถ๋ ฅ ๊ฒฐ๊ณผ number = 3 (๋ฐ๋์ด์์)
}
โถ ์์์ ๋ํ ์ฐธ์กฐ์
#include <iostream>
using namespace std;
int main() {
//int &ref = 4;
/* Error !
ref = 5; ๊ฐ ๊ฐ๋ฅํด์ง๊ธฐ ๋๋ฌธ.
๋ฐ๋ผ์ ์์๋ฅผ ์ฐธ์กฐํ๊ณ ์ถ๋ค๋ฉด const๋ฅผ ์ฌ์ฉํ์ฌ์ผ ํ๋ค. */
const int& ref = 4;
int a = ref;
cout << a << endl; // ์ถ๋ ฅ ๊ฒฐ๊ณผ a: 4
}
โถ ๋ ํผ๋ฐ์ค์ ๋ฐฐ์ด & ๋ฐฐ์ด์ ๋ ํผ๋ฐ์ค
๊ฒฐ๋ก ๋ถํฐ ๋งํ์๋ฉด ์ ์๋ ๋ถ๊ฐํ๋, ํ์๋ ๊ฐ๋ฅํ๋ค.
C++ ์์์ ๋ฐฐ์ด arr์ ์ ์ธ ์, ๋ฐฐ์ด์ ์ด๋ฆ arr์ ์ฒซ ๋ฒ์งธ ์์์ ์ฃผ์๊ฐ์ผ๋ก ๋ณํ ๊ฐ๋ฅํ์ฌ์ผ ํ๋ค.
ex) arr[1]๊ณผ *(arr+1)์ด ์๋ก ๋ฐ๋์ด์ ์ฒ๋ฆฌ ๊ฐ๋ฅ
>> ๋ฉ๋ชจ๋ฆฌ ์์์ ํด๋น ์์๊ฐ ์กด์ฌํจ์ ์๋ฏธ
๊ทธ๋ฌ๋ ์ฐธ์กฐ์๋ ๋ฉ๋ชจ๋ฆฌ ์์ ์กด์ฌํ์ง ์์ ๊ณต๊ฐ์ ์ฐจ์ง X
๋ฐฐ์ด์ ๋ ํผ๋ฐ์ค๋ ๊ฐ๋ฅํ๋ค.
int arr[3] = {1, 2, 3};
int(&ref)[3] = arr;