Prototype(ํ๋กํ ํ์ )
C++ ์์ ํจ์๋ฅผ ์ ์ธํ ๋, ์ฌ๋ฌ๊ฐ์ง ํธ์์ฑ์ ์ด์ ๋ก ํ๋กํ ํ์ ์ ์ ์ธํฉ๋๋ค.
๊ฐ์ฅ ํฐ ์ด์ ๋ก๋ ํจ์ ์ ์ธ์ ์์๋ฅผ ์ ๊ฒฝ์ฐ์ง ์์๋ ๋๋ ๊ฒ๊ณผ ๋ฌธ์์ ๊ฐ๋ ์ฑ์ ๋์ด๊ณ ์ฝ๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ ํ๋ ์ด์ ์ ๋๋ค.
ํ๋กํ ํ์ ์ ์์น๋ ๋ฌด์กฐ๊ฑด ํจ์์ ์ ์ธ ์ด์ ์ ์์ด์ผ ํฉ๋๋ค.
๊ด๋ก์ ์ผ๋ก๋, ํค๋ ์ดํ ํ๋กํ ํ์ ์ ์ธ์ ํ๊ณ , ๋ฉ์ธ ํจ์ ์ดํ์, ํ๋กํ ํ์ ์ผ๋ก ์ ์ธ๋ ํจ์๋ค์ ์ ์ธ์ ํฉ๋๋ค.
ํ๋กํ ํ์ ์ ํํ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
// Function Prototypes
void say_hello();
// ํจ์ Argument๊ฐ ์์ ๋
int add_nums(int, int);
int subt_nums(int n1, int n2);
// ํจ์ argument๊ฐ ์์ ๋, ๋ ํํ ๋ชจ๋ ๊ฐ๋ฅํฉ๋๋ค
double calc_tax(double, double);
ํจ์ ์ ๋ฌ ์ธ์(argument)๊ฐ ์์ ๋๋ ํจ์ ์ ์ธํ ๋์ ์๋ถ๋ถ์ ๋ผ๊ณ ์ธ๋ฏธ์ฝ๋ก (;)์ผ๋ก ๋ง๋ฌด๋ฆฌํ ๋ชจ์ต์ ๋๋ค.
argument๊ฐ ์์ ๋์๋, ๋๊ฐ์ง๋ก ๋ฐฉ๋ฒ์ด ๋๋๋๋ฐ, ์ ๋ฌ ๋ณ์๋ช ๊น์ง ๊ธฐ์ฌํ๊ฑฐ๋ ์ ํ๊ฑฐ๋ ์ ๋๋ค.
๋ ๋ฐฉ๋ฒ ๋ชจ๋ ์ ์์ ์ผ๋ก ์๋ํฉ๋๋ค.
์ด๋ ๊ฒ๋ง ํ๋ฉด ํด๋น ํจ์๊ฐ ๋ฌด์จ ๊ธฐ๋ฅ์ ํ๋์ง ๋ชจ๋ฅด๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ๊ฐ ์๊ฒ ์ฃ ?
๋น์ฐํ ์์ธํ ํจ์ ์ ์ธ์ ์ดํ์ ๋ค์ ํฉ๋๋ค.
void say_hello(){
cout << "Hello" << endl;
}
int add_nums(int n1, int n2){
return (n1 + n2);
}
int subt_nums(int n1, int n2){
return (n1 - n2);
}
double calc_tax(double base_cost, double tax){
return (base_cost += (base_cost * tax));
}
์ด ๋ถ๋ถ์ ์์์ ๋ง์๋๋ฆฐ๊ฒ ์ฒ๋ผ ๋ฉ์ธ ํจ์ ์ดํ์ ๋์ต๋๋ค.
์ด ๋ชจ๋ ๊ฒ์ ๋ฉ์ธ ํจ์๊น์ง ์ด์ด์ ์์ฑํ๋ฉด ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
// Function prototypes
#include <iostream>
using namespace std;
// PROTOTYPES
void say_hello();
// ํจ์ Argument๊ฐ ์์ ๋
int add_nums(int, int);
int subt_nums(int n1, int n2);
// ํจ์ argument๊ฐ ์์ ๋, ๋ ํํ ๋ชจ๋ ๊ฐ๋ฅํฉ๋๋ค
double calc_tax(double, double);
// MAIN
int main(){
say_hello();
cout << add_nums(10, 20) << endl;
cout << subt_nums(100,15) << endl;
calc_tax(100, 0.06) << endl;
}
// FUNCTION DEFINE
void say_hello(){
cout << "Hello" << endl;
}
int add_nums(int n1, int n2){
return (n1 + n2);
}
int subt_nums(int n1, int n2){
return (n1 - n2);
}
double calc_tax(double base_cost, double tax){
return (base_cost += (base_cost * tax));
}
Default Argument Values (๋ํดํธ ๋งค๊ฐ ๋ณ์)
์์ ์์์์, ์ธ๊ธ์ ๊ณ์ฐํ๋ ํจ์์ธ calc_tax์ ๋ํด์ ๋ถํธํ ๋ถ๋ถ์ด ์์ต๋๋ค.
๋๋ถ๋ถ์ ์ด์ฉ๊ฐ์ ๊ฐ์ ํผ์ผํธ์ ์ธ๊ธ์ ๋ด๊ณ ์๋๋ฐ, ์ด์ฉํ ๋ ๋ง๋ค ์ผ์ผํ 0.06์ ํ์ดํํ๊ธฐ๊ฐ ๊ท์ฐฎ์๊ฒ๋๋ค.
์ด๋ฐ ๊ฒฝ์ฐ๋ฅผ ์ํด default argument values๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค.
์ด๋ฅผ ์ง์ ํ๋ฉด, ์ปดํ์ผ๋ฌ์๊ฒ ๋งค๊ฐ ๋ณ์๊ฐ ์ฃผ์ด์ง์ง ์์์ ๋ ์ด๋ค ๊ฐ์ผ๋ก ํจ์๋ฅผ ์คํํ ์ง๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค.
๊ฐ์ฅ ์ข์ ๋ฐฉ๋ฒ์ ํ๋กํ ํ์ ์์ ์ง์ ํ๋ ๊ฒ์ ๋๋ค.
์ด๋ ์ผ๊ด์ฑ๊ณผ ์ ์ง๋ณด์์ ์ธก๋ฉด์์ ๋์ฑ ํธ๋ฆฌํฉ๋๋ค.
๋ํ, ๋ํดํธ ๊ฐ์ ์ง์ ํ ๋, ํ๋๋ง ๊ฐ๋ฅํ ๊ฒ์ด ์๋๋ผ ์ฌ๋ฌ ๋งค๊ฐ ๋ณ์์ ๋ํด์๋ ๊ฐ๋ฅํฉ๋๋ค.
๋ํดํธ ๊ฐ์ ์ค์ ํ๋ ๋ฐฉ๋ฒ์ ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค.
// Prototype
double calc_tax(double base_cost, double tax_rate = 0.06);
ํ๋กํ ํ์ ์ ์ ์ธํ ๋, ๋ณ์๋ช ๊น์ง ๊ธฐ์ฌํ ๋ค, ๊ฐ๊น์ง ํ ๋นํ๋ฉด ๋ค์ ๋๋ค.
์ด์ ์ฝ๋๋ก ํ๋ฒ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
// Function prototypes & Default variable values
#include <iostream>
using namespace std;
// PROTOTYPES
double calc_tax(double base_cost, double tax_rate = 0.06);
// MAIN
int main() {
cout << "$100 with tax rate of 6\% is: " << calc_tax(100) << endl;
cout << "$100 with tax rate of 6\% is: " << calc_tax(100, 0.06) << endl;
cout << "$100 with tax rate of 30\% is: " << calc_tax(100, 0.3) << endl;
return 0;
}
// FUNCTION DEFINE
double calc_tax(double base_cost, double tax) {
return (base_cost += (base_cost * tax));
}
์์์ ์ค๋ช ํ ๋๋ก ํ๋กํ ํ์ ์ ์ธ ์์ default value๋ฅผ ์ง์ ํ์ต๋๋ค.
์ดํ๋ ๊ธฐ์กด๊ณผ ๋์ผํ์ง๋ง, ๋ฉ์ธ ํจ์์์ calc_tax ํจ์๋ฅผ ์ฌ์ฉํ ๋ ์ธ๊ธ ํผ์ผํธ๋ฅผ ์ ๋ ฅํ์ง ์์๋ ๋ฌธ์ ์์ด ์ถ๋ ฅ๋ฉ๋๋ค.
'C++ > ํจ์ (Function)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++] ํจ์์์ ํฌ์ธํฐ๋ฅผ ๋ฐํํ๊ธฐ (Returning a Pointer from a Function) (1) | 2023.12.22 |
---|---|
[C++] ์ฌ๊ท ํจ์ (Recursive Function) (0) | 2023.12.18 |
[C++] ์ฐธ์กฐ๋ก ์ ๋ฌํ๊ธฐ (Pass by Reference) (1) | 2023.12.17 |
[C++] ํจ์์ ๋ฐฐ์ด์ ๋งค๊ฐ๋ณ์๋ก ์ฌ์ฉํ ๋ (Passing Arrays To Functions) (3) | 2023.12.17 |
[C++] ํจ์ ์ค๋ฒ๋ก๋ฉ (Function Overloading) (1) | 2023.12.17 |