Day13.默认函数参数，占位参数，函数重载

Day13.2021.11.23

函数默认参数

一旦开始有默认值，后面必须都要有默认值

#include"methodState.h"
 int func(int a, int b = 20, int c=30) {
     return a + b + c;
 }
 /*
     一旦开始有默认值，后面必须都要有默认值
     int func(int a, int b = 20, int c) c 必须赋值
 */
 int main() {
 ​
     cout << func(10) << endl;//只赋值a
     cout << func(10,30) << endl;//70
     system("pause");
     return 0;
 }

 

函数声明有默认参数，函数实现就不能有默认参数。声明和实现只能有一个地方有默认参数

 #include"methodState.h"
 /*函数声明有默认参数，函数实现就不能有默认参数*/
 int func1(int a, int b = 20, int c = 30);
 int main() {
     cout << func1(10, 10, 10);
     system("pause");
     return 0;
 }
 int func1(int a, int b = 20, int c = 30) {//报错：重定义默认参数
     return a + b + c;
 }

 

占位参数

 #include"methodState.h"
 //占位参数
 int func(int a, int b , int c,int ) {//函数内部无法调用，后续会用到
     return a + b + c;
 }
 int func1(int a, int b, int c, int =20) {//占位参数可以有默认值
     return a + b + c;
 }
 int main() {
 ​
     cout << func(1, 2, 3, 4) << endl;//必须传进去一个整型数据
     cout << func1(1, 2, 3, 4) << endl;
     cout << func1(1, 2, 3) << endl;

 

函数重载

满足条件：

1. 同一作用域下（都是全局函数）

2. 函数名称相同

3. 参数 类型/个数/顺序 不同

重载规则

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；

• 被重载的方法可以改变返回类型；

• 被重载的方法可以改变访问修饰符；

• 被重载的方法可以声明新的或更广的检查异常；

• 方法能够在同一个类中或者在一个子类中被重载。

• 无法以返回值类型作为重载函数的区分标准。

参考资料：重载和重写

 #include"methodState.h"
 //函数重载
 int sum(int a, int b) {
     return a + b;
 }
 int sum(double a, int b) {
     return a + b;
 }
 int sum(int a, double b) {
     return a + b;
 }
 double sum(double a, double b) {
     return a + b;
 }
 int sum(int a, int b, int c) {
     return a + b + c;
 }
 double sum(double a, int b, int c) {
     return a + b + c;
 }
 double sum(int a, double b, int c) {
     return a + b + c;
 }
 double sum(int a, int b, double c) {
     return a + b + c;
 }
 double sum(double a, double b, int c) {
     return a + b + c;
 }
 double sum(double a, int b, double c) {
     return a + b + c;
 }
 double sum(int a, double b, double c) {
     return a + b + c;
 }
 double sum(double a, double b, double c) {
     return a + b + c;
 }
 int main() {
     cout << sum(3.14, 6) << endl;
     cout << sum(18, 6) << endl;
     cout << sum(3.14, 6.14) << endl;
     cout << sum(3.14, 6,9.14) << endl;
     system("pause");
     return 0;
 }

 

注意事项：

1. 引用作为重载的条件

 void func(const int &a) {
     cout << "func(const int &a)调用" << endl;
 }
 void func(int& a) {
     cout << "func(int &a)调用" << endl;
 }
 ​
 int main() {
 ​
     int a = 10;
     func(a); //func(int& a)调用
 ​
     const int b = 10;
     func(b); //func(const int& a)调用
 ​
     func(10); //func(const int& a)调用
 ​
     system("pause");
     return 0;
 }

 

但我搞不懂这一块

 void func(const int &a) {
     cout << "func(const int &a)调用" << endl;
 }
 void func(int a) {
     cout << "func(int a)调用" << endl;
 }
 int main() {
     int a = 10;
     func(a); //为什么这报错，这个变量10为什么都可以进
     system("pause");
     return 0;
 }

 

个人理解：参数是const int &a与int& a相比，拿一个变量会进int& a，只是相比来说会进int& a

但如果把这两个单拿出来也是能进变量，所以把参数是const int &a和int a放一起重载会报错，参数是int &a和int a放一起重载也会报错

2. 函数重载碰到默认参数

 void func(int a,int b=10) {
     cout << "func(int a,int b=10)调用" << endl;
 }
 void func(int a) {
     cout << "func(int a)调用" << endl;
 }
 int main() {
     //func(10);
     system("pause");
     return 0;
 }

 

能够编译，但无法运行，因为只传一个参数两个重载都可以走，应避免出现

P98结束

来源：b站黑马