缺省参数与函数重载

缺省概念

缺省参数是指为声明函数或定义函数时为函数的参数指定的一个缺省值，在函数调用时，若没有指定的实参则使用缺省值，否则使用指定的实参

void Func(int a = 0) 
{
	cout << a << endl;
}

int main()
{
	Func();     // 没有传参时，使用参数的默认值，即a = 0
	Func(10);   // 传参时，使用指定的实参
	return 0;
}

---

缺省参数使用及注意项

• 全省参数：函数的每个参数都有缺省值，传参时，可传任意多个参数，且参数的传参是从左到右依次进行

  using namespace std;
  
  void Func(int a = 1, int b = 2, int c = 3)
  {
  	cout << "a = " << a << endl;   
  	cout << "b = " << b << endl;   
  	cout << "c = " << c << endl;   
  }
  
  int main()
  {
  	Func();          // a = 1, b = 2, c = 3
  	Func(10);        // a = 10, b = 2, c = 3
  	Func(10,20);     // ......依次往下
  	Func(10,20,30);
  	return 0;
  }

• 半缺省参数：函数的部分参数有缺省值，且缺省值要从右到左依次给

  #include<iostream>
  using namespace std;
  
  void Func(int a, int b = 2, int c = 3)
  {
  	cout << "a = " << a << endl;
  	cout << "b = " << b << endl;
  	cout << "c = " << c << endl;
  }
  
  int main()
  {
  	Func();          // 编译报错，因为a无参数 
  	Func(10);
  	Func(10, 20);
  	Func(10, 20, 30);
  	return 0;
  }
  
  

半缺省注意项：

1，缺省值要从右到左依次给，不能间隔着给

void Func(int a = 1, int b, int c = 3)
{
    cout << "a = " << a << endl;   
	cout << "b = " << b << endl;   
	cout << "c = " << c << endl;  
}

int main()
{
	Func(10);       
	return 0;
}

这么写就是错的，指定的实参10，会直接赋值a，并不会因为a 存在缺省值，跳过a，赋值b，最后b既无实参也无缺省值，程序终止。

2，缺省参数不能在函数声明和定义中同时出现

声明
void Func(int a = 10);  
  

函数定义
void Func(int a = 20)
{}
  
如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。

3，缺省值必须是常量或者全局变量

---

重载概念

函数重载是一种特殊的情况，c++允许在同一作用域中声明几个类似的同名函数，这些同名函数的形参列表（参数个数，类型，顺序）必须不同，常用来处理实现功能类似数据类型不同的问题

---

函数重载定义

函数重载规则：

• 函数名称必须相同
• 参数列数必须不同（个数不同，类型不同，参数顺序不同）三者中必须有一个不同
• 函数的返回类型可以相同也可以不同
• 仅仅返回类型不同不足以成为函数重载

1、参数类型不同

#include<iostream>
using namespace std;

int Add(int left, int right) 
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}

double Add(double left, double right) 
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}


int main()
{
	Add(10, 20);
	Add(10.1, 20.2);
	return 0;
}

 2、参数个数不同

#include<iostream>
using namespace std;

void f()
{
	cout << "f()" << endl;
}

void f(int a)
{
	cout << "f(int a)" << endl;
}

int main()
{
	f();
	f(10);
	return 0;
}

 3、参数类型顺序不同

参数类型顺序不同，本质是两个不同类型的参数 ，顺序不同。若两参数类型相同，仅仅只是参数变量顺序不同，则不构成重载

#include<iostream>
using namespace std;

//构成重载
void f(int a, char b) 
{
	cout << "f(int a,char b)" << endl;
}

void f(char b, int a) 
{
	cout << "f(char b, int a)" << endl;
}


//不构成重载
void f(int a, int b) 
{
	cout << "f(int a,char b)" << endl;
}

void f(int b, int a) 
{
	cout << "f(char b, int a)" << endl;
}


int main()
{
    f(10, 'a');
	f('a', 10);
	return 0;
}

注：如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办

法区分

---

重载与缺省

• 构成重载

  void f()
  {
  	cout << "f()" << endl;
  }
  
  void f(int a)
  {
  	cout << "f(int a)" << endl;
  }

• 不构成重载

  void f(int a = 0)
  {
  	cout << "f()" << endl;
  }
  
  void f(int a)
  {
  	cout << "f(int a)" << endl;
  }

• 构成重载，但运行错误

  void f()
  {
  	cout << "f()" << endl;
  }
  
  void f(int a = 0)
  {
  	cout << "f(int a)" << endl;
  }

  这种情况，两函数均可不传实参，编译器无法匹配，最终进行报错。