ํจ์๋ฅผ ์ง์ํ๋ ํฌ์ธํฐ
๋ค๋ฅธ ํจ์์ ์ฃผ์๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ทจํ๋ ํจ์ ์์ฑ ๊ฐ๋ฅ
์ฆ, ์ฒซ ๋ฒ์ฌ ํจ์๊ฐ ๋ ๋ฒ์งธ ํจ์๋ฅผ ๋ฉ๋ชจ๋ฆฌ์์ ์ฐพ์๋ด ์คํํ๋๋ก ํ ์ ์๋ค. ์ด ๋ฐฉ์์ ๋ค๋ฅธ ์๊ฐ์ ๋ค๋ฅธ ํจ์์ ์ฃผ์๋ฅผ ์ ๋ฌํ๋ ๊ฒ์ ๊ฐ๋ฅํ๊ฒ ๋ง๋ ๋ค. ์ฒซ ๋ฒ์งธ ํจ์๊ฐ ๋ค๋ฅธ ์๊ฐ์ ๋ค๋ฅธ ํจ์๋ฅผ ์ฌ์ฉํ ์ ์๋ค๋ ๊ฒ์ ์๋ฏธ
ํจ์ ํฌ์ธํฐ์ ๊ธฐ์ด
1. ํจ์์ ์ฃผ์ ์ป๊ธฐ
think()๊ฐ ํจ์๋ผ๋ฉด think๋ ๊ทธ ํจ์์ ์ฃผ์. ํจ์๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌํ๋ ค๋ฉด ํจ์ ์ด๋ฆ๋ง ์ ๋ฌํ๋ฉด ๋จ.
process(think); //think()์ ์ฃผ์ ์ ๋ฌ
thought(think()); // thought()์ think()์ ๋ฆฌํด๊ฐ ์ ๋ฌ
2. ํจ์๋ฅผ ์ง์ํ๋ ํฌ์ธํฐ์ ์ ์ธ
ํจ์๋ฅผ ์ง์ํ๋ ํฌ์ธํฐ๋ฅผ ์ ์ธํ ๋, ๊ทธ ํฌ์ธํฐ๊ฐ ์ง์ํ๋ ํจ์์ ๋ฐ์ดํฐํ์ ์ง์ ํด์ผํจ
ex)
double pam(int); //ํจ์ ์ํ
double (*pf)(int); //pf๋ ํ๋์ int๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ทจํ๊ณ double ํ์ ๋ฆฌํดํ๋ ํจ์๋ฅผ ์ง์ํจ
์ผ๋ฐ์ ์ผ๋ก, ํจ์์ ์ํ์ ๋จผ์ ์์ฑํ ํ, ํจ์ ์ด๋ฆ์ (*pf) ํํ์ ํํ์์ผ๋ก ๋์ฒดํ๋ค. ์ด ๊ฒฝ์ฐ, pf๋ ๊ทธ ๋ฐ์ดํฐํ์ ํจ์๋ฅผ ์ง์ํ๋ ํฌ์ธํฐ์ด๋ค.
๊ดํธ๋ * ์ฐ์ฐ์๋ณด๋ค ์ฐ์ ์์๊ฐ ๋๋ค.
double (*pf)(int); // pf๋ double์ ๋ฆฌํดํ๋ ํจ์๋ฅผ ์ง์ํ๋ ํฌ์ธํฐ
double *pf(int); //pf()๋ doubleํ์ ์ง์ํ๋ ํฌ์ธํฐ๋ฅผ ๋ฆฌํดํ๋ ํจ์
void estimate(int lines,double (*pf)(int)); // ํจ์ ์ํ
estimate(50,pam); // ํจ์ ์ฃผ์์ ์ ๋ฌ
3. ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ์ฌ ํจ์ ๋ถ๋ฌ๋ด๊ธฐ
double pam(int);
double (*pf)(int);
pf=pam;
double x=pam(4);
double y=(*pf)(5);
c++์ pf๋ ํจ์ ์ด๋ฆ์ฒ๋ผ ์ฌ์ฉํ๋ ๊ฒ์ ํ์ฉํจ.
double y = pf(5);
ํจ์ ํฌ์ธํฐ์ ๋ณํ
๋ค์์ ๋์ผํ ํน์ง๊ณผ ๋ฆฌํด ๊ฐ์ ๊ฐ์ง๋ ํจ์ ์ํ๋ค์ด๋ค.
const double *f1(const double ar[],int n);
const double *f2(const double[],int);
const double *f3(const double *,int);
๋ค์ ์ด ์ธ ๊ฐ์ ํจ์๋ฅผ ๊ฐ๋ฆฌํฌ ์ ์๋ ํฌ์ธํฐ
const double *(*p1)(const double *,int);
์ด๊ธฐํ ํํ๋ก ์กฐํฉ ๊ฐ๋ฅ
const double *(*p1)(const double *,int)=f1;
c++ ์๋ ํ ๋ณํ ์ฌ์ฉ
auto p2=f2;
ํจ์ ํฌ์ธํฐ์ ๋ฐฐ์ด
const double *(*pa[3])(const double *,int) = {f1,f2,f3};
1. ์ธ ๊ฐ์ ์์๋ฅผ ๊ฐ์ง๋ ๋ฐฐ์ด์ ์ ์ธ pa[3];
2. ์ฐ์ฐ์ ์ฐ์ ์์์์ []๊ฐ *๋ณด๋ค ๋์ผ๋ฏ๋ก *pa[3],[a๋ ์ธ ๊ฐ์ ํฌ์ธํฐ๋ฅผ ์์๋ก ๊ฐ์ง๋ ๋ฐฐ์ด์ด๋ผ๋ ์๋ฏธ
3. ๊ฐ ํฌ์ธํฐ๋ค์ด ๊ฐ๋ฆฌํค๋ ๊ฒ์ด ๋ฌด์์ธ์ง ๋ํ๋ด์ค๋ค
const double *(*pa[3])(const double *,int)
auto ์ฌ์ฉ ๋ถ๊ฐ๋ฅ -> ์๋ ํ ๋ณํ์ ๋จ์ผ ๊ฐ์ ์ด๊ธฐํํ ๋ ์ฌ์ฉ๋๋ฉฐ, ๋ฆฌ์คํธ๋ฅผ ์ด๊ธฐํ ํ ๋๋ ์ฌ์ฉ ๋ถ๊ฐ
๊ทธ๋ฌ๋ ๋ฐฐ์ด pa์ ๋ํ์ฌ ๋ค์๊ณผ ๊ฐ์ ๋์ ์ผ๋ก ์ ์ธ ๊ฐ๋ฅ
auto pb = pa;
ํจ์ ํธ์ถ ๋ฐฉ๋ฒ
๋ฐฐ์ด์ ์ด๋ฆ์ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ๊ฐ๋ฆฌํค๊ธฐ ๋๋ฌธ์, pa์ pb๋ ํจ์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ์ด๋ค.
pa[i]์ pb[i]๋ ๋ชจ๋ ๋ฐฐ์ด ๋ด์ ์กด์ฌํ๋ ํฌ์ธํฐ์ด๊ณ , ๊ฐ ์์๋ฅผ ๊ฐ๋ฆฌํค๋ ํํ์์ผ๋ก ๊ฐ ํจ์๋ฅผ ํธ์ถํ๋ฉด ๋๋ค.
const double *px=pa[0](av,3);
const double *py=(*pb[i])(av,3);
double ๊ฐ์ ์ป๊ธฐ ์ํด *์ฐ์ฐ์ ์ฌ์ฉ ๊ฐ๋ฅ
double x=*pa[0](av,3);
double y=*(*pb[1])(av,3);
auto pc=&pa; // ์ ์ฒด ๋ฐฐ์ด์ ๊ฐ๋ฆฌํจ๋ค
const double * (*(*pd)[3])(const double *,int)=&pa;
*pd[3] // 3๊ฐ ํฌ์ธํฐ๋ค์ ๋ฐฐ์ด
(*pd)[3] // 3๊ฐ์ ์์๋ฅผ ๊ฐ์ง๋ ๋ฐฐ์ด์ ํฌ์ธํฐ
typedef๋ฅผ ์ด์ฉํ ๋จ์ํ
typedef const double *(*p_fun)(const double *,int);
p_fun p1=f1;
p_fun pa[3]={f1,f2,f3};
p_fun (*pd)[3]=&pa;
c++ ์ธ๋ผ์ธ(inline) ํจ์
์ธ๋ผ์ธ ํจ์์์๋ ์ปดํ์ผ๋ ํจ์ ์ฝ๋๊ฐ ํ๋ก๊ทธ๋จ์ ๋ค๋ฅธ ์ฝ๋ ์์ ์ง์ ์ฝ์ ๋์ด ์๋ค.
์ผ๋ฐ์ ์ธ ํจ์์ ํธ์ถ์ ํ๋ก๊ทธ๋จ์ ๋ค๋ฅธ ์ฃผ์๋ก ์ ํ์์ผฐ๋ค๊ฐ, ํจ์์ ์ฒ๋ฆฌ๊ฐ ์ข ๊ฒฐ๋๋ฉด ๋ค์ ์๋์ ์๋ฆฌ๋ก ๋์์จ๋ค.
๋ฐ๋ผ์ ์ธ๋ผ์ธ ํจ์๋ ์ผ๋ฐ ํจ์๋ณด๋ค ์ฝ๊ฐ ๋น ๋ฅด๊ฒ ์ํ๋๋ค. ๊ทธ๋ฌ๋ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ ์ธก๋ฉด์์ ๋ ์ธ๋ผ์ธ ํจ์๊ฐ ์ผ๋ฐ ํจ์๋ณด๋ค ๋ถ๋ฆฌํจ.
ํจ์ ์ฝ๋ ์์ฒด๋ฅผ ์ํํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด, ํจ์ ํธ์ถ์ ๊ณผ์ ์ ์ฒ๋ฆฌํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋นํด ๋งค์ฐ ๊ธธ ๊ฒฝ์ฐ, ์ ์ฒด์ ์ผ๋ก ์ ์ฝ๋๋ ์๊ฐ์ ๊ฑฐ์ ์๋ค. ๋น๋ฒํ๊ฒ ํธ์ถ๋๋ ํจ์๊ฐ ์๋๋ผ๋ฉด, ์ ๋์ ์ธ ์๊ฐ ์ ์ฝ์ ๊ทธ๋ค์ง ํฌ์ง ์๋ค.
์ธ๋ผ์ธ ํจ์๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด ๋ค์ ๋ ๊ฐ์ง ์์ ์ค์ ์ ์ด๋ ํ ๊ฐ์ง๋ฅผ ๋ฐ๋์ ํด์ผํ๋ค.
1. ํจ์ ์ ์ธ ์์ inline์ ๋ถ์ธ๋ค.
2. ํจ์ ์ ์ ์์ inline์ ๋ถ์ธ๋ค.
ํจ์ ์ ์๊ฐ ํ ํ ๋๋ ๋ ๊ฐ์ ํ์ ๋ฃ์ ์ ์์ ์ ๋๋ก ํฌ๋ค๋ฉด, ๊ทธ ํจ์๋ ์ธ๋ผ์ธ ํจ์๋ก ์ ํฉํ์ง ์๋ค.