์ฐธ์กฐ ๋ณ์
์ฐธ์กฐ(reference)๋ ๋ฏธ๋ฆฌ ์ ์๋ ์ด๋ค ๋ณ์์ ์ค์ ์ด๋ฆ ๋์ ์ธ ์ ์๋ ๋์ฉ ์ด๋ฆ์ด๋ค. ์ฐธ์กฐ์ ์ฃผ๋ ์ฉ๋๋ ํจ์์ ํ์ ๋งค๊ฐ๋ณ์์ ์ฌ์ฉํ๋ ๊ฒ. ์ฐธ์กฐ๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ฌ์ฉํ๋ฉด, ๊ทธ ํจ์๋ ๋ณต์ฌ๋ณธ ๋์ ์๋ณธ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง๊ณ ์์ ํจ
์ฐธ์กฐ ๋ณ์์ ์ ์ธ
c์ c++์ ๋ณ์์ ์ฃผ์๋ฅผ ๋ํ๋ด๊ธฐ ์ํด & ๊ธฐํธ๋ฅผ ์ฌ์ฉ
int rats;
int & rodents=rats; // rodents๋ฅผ rats์ ๋์ฉ ์ด๋ฆ์ผ๋ก ๋ง๋ฌ
rats์ rodents๋ ๊ฐ์ ๊ฐ๊ณผ ๊ฐ์ ์ฃผ์๋ฅผ ๊ฐ์ง๊ณ ์์
์ฐธ์กฐ๋ ๋ง๋ค ๋ ๋ฐ๋์ ์ด๊ธฐํ๋ฅผ ํด์ผ ํ๊ณ , ์ผ๋จ ์ด๋ค ํน์ ๋ณ์์ ์ฐ๊ฒฐ๋๋ฉด ๊ทธ๊ฒ์ ๊ณ ์ํด์ผ ํจ
int rats=101;
int & rodents=rats;
int bunnies=50;
rodents=bunnies; // rats=bunnies์ ๊ฐ์
ํจ์ ๋งค๊ฐ๋ณ์๋ก์์ ์ฐธ์กฐ
๊ฐ์ผ๋ก ์ ๋ฌ -> ๋ ๊ฐ์ ๋ณ์, ๋ ๊ฐ์ ์ด๋ฆ
void sneezy(int x);
int main()
{
int times=20;
sneezy(times); //times๋ผ๋ ๋ณ์๋ฅผ ๋ง๋ค๊ณ ๊ฐ 20 ๋์
...
}
void sneezy(int x) // x๋ผ๋ ๋ณ์๋ฅผ ๋ง๋ค๊ณ ์ ๋ฌ๋ ๊ฐ 20 ๋์
{
...
}
์ฐธ์กฐ๋ก ์ ๋ฌ -> ํ ๊ฐ์ ๋ณ์, ๋ ๊ฐ์ ์ด๋ฆ
void grumpy(int &x);
int main()
{
int times=20;
grumpy(times);
...
}
void grumpy(int &x)
{
...
}
์ฐธ์กฐ์ ํน์ฑ
ํจ์์ ์ ๋ฌํ๋ ์ ๋ณด๋ฅผ ๊ทธ ํจ์๊ฐ ๋ณ๊ฒฝํ์ง ์๊ณ ์ฌ์ฉ๋ง ํ๋๋ก ํ๋ ค๋ฉด, ์์ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํด์ผ ํจ
double refcube(const double &ra);
ra๊ฐ ์ด๋ค ๋ณ์์ ๋์ฉ ์ด๋ฆ์ด๋ผ๋ฉด, ๊ทธ ๋ณ์๋ฅผ ์ค์ ๋งค๊ฐ๋ณ์๋ก ์ฌ์ฉํด์ผ ํ๋ค. ๋ฐ๋ผ์ ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ ์๋ชป๋จ.
double z=refcube(x+3.0);
์์ ๋ณ์, ์ฐธ์กฐ ๋งค๊ฐ๋ณ์, const
c++์ ์ค์ ๋งค๊ฐ๋ณ์์ ์ฐธ์กฐ ๋งค๊ฐ๋ณ์๊ฐ ์ผ์นํ์ง ์์ ๋ ์์ ๋ณ์ ์์ฑ ๊ฐ๋ฅ. ์ต๊ทผ์ c++์ ๋งค๊ฐ๋ณ์๊ฐ const ์ฐธ์กฐ์ผ ๊ฒฝ์ฐ์๋ง ์ด๊ฒ์ ํ์ฉ
์ฐธ์กฐ ๋งค๊ฐ๋ณ์๊ฐ const์ผ ๊ฒฝ์ฐ, ์ปดํ์ผ๋ฌ๋ ๋ค์๊ณผ ๊ฐ์ ๋ ๊ฐ์ง ์ํฉ์์ ์์ ๋ณ์๋ฅผ ์์ฑํจ.
1. ์ค์ ๋งค๊ฐ๋ณ์๊ฐ ์ฌ๋ฐ๋ฅธ ๋ฐ์ดํฐํ์ด์ง๋ง lvalue๊ฐ ์๋ ๋
2. ์ค์ ๋งค๊ฐ๋ณ์๊ฐ ์๋ชป๋ ๋ฐ์ดํฐํ์ด์ง๋ง ์ฌ๋ฐ๋ฅธ ๋ฐ์ดํฐํ์ผ๋ก ๋ณํํ ์ ์์ ๋
lvalue ๋งค๊ฐ๋ณ์๋ ์ฐธ์กฐ๊ฐ ๊ฐ๋ฅํ ๋ฐ์ดํฐ ๊ฐ์ฒด์ด๋ค.
์๋ฅผ ๋ค์ด ๋ณ์, ๋ฐฐ์ด์ ์์, ๊ตฌ์กฐ์ฒด์ ๋ฉค๋ฒ, ์ฐธ์กฐ ๋๋ ์ญ์ฐธ์กฐ ํฌ์ธํฐ๋ lvalue์ด๋ค.
c์์ lvalue๋ ๋ณธ๋ ๋์ ๋ฌธ ์ผํธ์ ๋ํ๋ ์ ์๋ ๋ ๋ฆฝ์ฒด๋ค์ ์๋ฏธํ์ผ๋, ์ง๊ธ์ ์ผ๋ฐ ๋ณ์์ const๋ณ์ ๋ชจ๋ ์ฃผ์์ ์ํด ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ฏ๋ก lvalue๋ก ๊ณ ๋ ค๋ ์ ์๋ค.
double refcube(const double &ra)
{
return ra*ra*ra;
}
double side=3.0;
double *pd=&side;
double &rd=side;
long edge=5L;
double lens[4]={2.0,5.0,10.0,12.0};
double c1=recube(side); //ra๋ side
double c2=recube(lens[2]);//ra๋ lens[2]
double c3=recube(rd);//ra๋ rd์ด๋ฉฐ side
double c4=recube(*pd);//ra๋ *pd์ด๋ฉฐ side
double c5=recube(edge);//ra๋ ์์ ๋ณ์
double c6=recube(side+10.0);//ra๋ ์์ ๋ณ์
๋งค๊ฐ๋ณ์ side, lens [2], rd,*pd๋ ์ด๋ฆ์ ๊ฐ์ง๊ณ ์๋ doubleํ ๋ฐ์ดํฐ ๊ฐ์ฒด์ด๋ค. ๋ฐ๋ผ์ ์ฐธ์กฐ ๋งค๊ฐ๋ณ์๋ก ์์ฑ ๊ฐ๋ฅ
edge๋ ๋ณ์์ง๋ง ๋ฐ์ดํฐํ์ด ์ผ์นํ์ง ์๋๋ค
๋งค๊ฐ๋ณ์ 7.0๊ณผ side+10.0์ ๋ฐ์ดํฐํ์ ์ผ์นํ์ง๋ง, ์ด๋ฆ์ ๊ฐ์ง๊ณ ์๋ ๋ฐ์ดํฐ ๊ฐ์ฒด๊ฐ ์๋๋ค.
์ด๋ฌํ ๊ฒฝ์ฐ, ์ปดํ์ผ๋ฌ๋ ์ต๋ช ์ ์์ ๋ณ์๋ฅผ ๋ง๋ค๊ณ , ra๋ก ํ์ฌ๊ธ ๊ทธ๊ฒ์ ์ฐธ์กฐํ๊ฒ ํจ. ์์ ๋ณ์๋ ํจ์๊ฐ ํธ์ถ๋์ด์๋ ๋์ ์ ์ง๋์ง๋ง, ๊ทธ ํ ์ปดํ์ผ๋ฌ๋ ์์ ๋ณ์ ์ญ์ ๊ฐ๋ฅ
ex)
void swapr(int &a,int &b)
{
int temp;
temp=a;
a=b;
b=temp;
}
long a=3,b=5;
swapr(a,b);
๋ฐ์ดํฐํ์ด ์ผ์นํ์ง ์์ผ๋ฏ๋ก, ์ปดํ์ผ๋ฌ๋ ๋ ๊ฐ์ intํ ์์ ๋ณ์๋ฅผ ๋ง๋ค๊ณ ๊ทธ๊ฒ๋ค์ 3๊ณผ 5๋ก ์ด๊ธฐํํ ํ ์์ ๋ณ์์ ๋ด์ฉ์ ์๋ก ๊ตํ. ์ฆ a์ b๋ ๊ตํ๋์ง ์์
๊ธฐ๋ณธ์ ์ผ๋ก, ํ์ ๋งค๊ฐ๋ณ์๊ฐ const ์ฐธ์กฐ๋ก ๋์ด์๋ ํจ์๋, ๋ฐ์ดํฐํ์ด ์ผ์นํ์ง ์๋ ๋งค๊ฐ๋ณ์๋ฅผ ์ ๋ฌ๋ฐ์์ ๋, ์ ๋ณด๋ฅผ ๊ฐ์ผ๋ก ์ ๋ฌ๋ฐ๋ ์ ํต์ ์ธ ๋ฐฉ์์ ๋ฐ๋ฆ.
๊ตฌ์กฐ์ฒด์ ๋ํ ์ฐธ์กฐ
๊ตฌ์กฐ์ฒด์ ๋ํ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์, ๊ตฌ์กฐ์ฒด ๋งค๊ฐ๋ณ์๋ฅผ ์ ์ธํ ๋ ์ฐธ์กฐ ์ฐ์ฐ์ &๋ฅผ ์์ ๋ถ์ด๋ฉด ๋๋ค.
struct free_throws
{
std::string name;
int made;
int attemps;
float percent;
};
void set_pc(free_throws & ft);
void display(const free_throws &ft);
์ฐธ์กฐ๋ฅผ ๋ฆฌํดํ๋ ์ด์
์ฐธ์กฐ๋ฅผ ๋ฆฌํดํ์ง ์์ ๊ฒฝ์ฐ
double m=sqrt(16.0);
cout<<sqrt(25.0);
1. ์ฒซ ๋ฒ์งธ ๊ตฌ๋ฌธ์์ ๊ฒฐ๊ณผ ๊ฐ์ธ 4.0์ ์์ ์ฅ์์ ๋ณต์ฌ๋จ
2. ์์ ์ฅ์์ ์๋ ๊ทธ ๊ฐ์ m์ผ๋ก ๋ณต์ฌ๋จ
1. ๋ ๋ฒ์งธ ๊ตฌ๋ฌธ์์ ๊ฒฐ๊ณผ ๊ฐ์ธ 5.0์ ์์ ์ฅ์์ ๋ณต์ฌ๋จ
2. ๊ทธ ์์ ์ฅ์์ ๋ด์ฉ๋ค์ด cout๋ก ์ ๋ฌ๋จ.
dup=accumulate(team,five);
๋ง์ฝ accumulate()๊ฐ ๊ตฌ์กฐ์ฒด ์์ฒด๋ฅผ ๋ฆฌํดํ ๊ฒฝ์ฐ, ์ ์ฒด ๊ตฌ์กฐ์ฒด๋ฅผ ์์ ์ฅ์์ ๋ณต์ฌํ๊ณ , ๊ทธ ๋ณต์ฌํ ๊ฒ์ dup์ ๋ณต์ฌํ ๊ฒ์ด๋ค. ๊ทธ๋ฌ๋, ์ฐธ์กฐ๋ฅผ ๋ฆฌํด์ผ๋ก ์ฌ์ฉํ ๊ฒฝ์ฐ, team์ ์ง์ ์ ์ผ๋ก dup์ ๋ณต์ฌ๋๊ธฐ ๋๋ฌธ์ ๋ณด๋ค ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ด ๋ ์ ์๋ค.
์ฐธ์กฐ๋ฅผ ๋ฆฌํดํ ๋ ์ฃผ์ํ ์
ํจ์๊ฐ ์ข ๋ฃ๋ ๋ ์๋ช ์ด ํจ๊ป ๋๋๋ ๋ฉ๋ชจ๋ฆฌ ์์น์ ๋ํ ์ฐธ์กฐ๋ฅผ ๋ฆฌํดํ์ง ์๋๋ก ์กฐ์ฌํด์ผ ํจ
const free_throws & clone2(free_throws &fit)
{
free_throws newguy;
newguy=ft;
return newguy;
}
์ด ๋ฌธ์ ๋ฅผ ํผํ๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ์, ํจ์์ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ๋ ์ฐธ์กฐ๋ฅผ ๋ฆฌํดํ๋ ๊ฒ.
์๋ก์ด ์ ์ฅ์๋ฅผ ์์ฑํ๊ธฐ ์ํ ๋ ๋ฒ์งธ ๋ฐฉ๋ฒ์ new๋ฅผ ์ฌ์ฉํ์ฌ ์๋ก์ด ๊ธฐ์ต ๊ณต๊ฐ์ ๋ง๋๋ ๊ฒ, ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํ์ฌ ์ด์ ๋น์ทํ ์ผ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ
const free_throws & clone(free_throws &ft)
{
free_throws *pt;
*pt=ft;
return *pt;
}
์ฐธ์กฐ๋ฅผ ๋ฆฌํดํ ๋ const๋ฅผ ์ฌ์ฉํ๋ ์ด์
accumulate ํจ์๊ฐ ์ฐธ์กฐ๋ฅผ ๋ฆฌํดํ๋ค๊ณ ํ์.
accumulate(dup,five)=four;
๋์ ์ ํ๋ ค๋ฉด ์ข์ธก์ ์์ ๊ฐ๋ฅํ lvalue๊ฐ ํ์, ์ด ๊ฒฝ์ฐ accumulateํจ์๊ฐ ์ฐธ์กฐ ๋ณ์๋ฅผ dup์ ๋๋ ค๋ณด๋ด๋๋ฐ ์ด๊ฒ์ด ์์ ๋ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ์๋ณํ๊ธฐ ๋๋ฌธ์ ์ ํจํจ.
๋ฐ๋ฉด, ์ผ๋ฐ ๋ฆฌํด ํ์ ์ rvalue๋ก์, ์ฃผ์๋ก ์ ์ ๋ถ๊ฐ
๋ฆฌํดํ์ ์์ ์ฐธ์กฐ๋ก ๋ง๋ค๊ธฐ
const free_throws &accumulate(free_throws & target,const free_throws &source);
๋ฆฌํดํ์ด const์ด๋ฏ๋ก ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅํ lvalue;
์ด๋ค ํจ์์ ๋ํ ๊ณต์ ๋งค๊ฐ๋ณ์๊ฐ const free_throws & ์ผ ๊ฒฝ์ฐ function(accumulate(team,two)); ๊ณผ ๊ฐ์ ๊ตฌ๋ฌธ ํ์ฉ