C++学习笔记 - 阶段三：C++核心编程 - Chapter3：函数高级

阶段三：C++核心编程

Chapter3：函数高级

3.1 函数的默认参数

在C++中，函数的形参列表中的形参是可以有默认值的。
语法：返回值类型 函数名 （参数= 默认值）{ }

#include "iostream"
using namespace std;

int func(int a, int b = 10, int c = 10) //在C++中，函数的形参列表中的形参是可以有默认值的。
{
	return a + b + c;
}
int func2(int a = 10, int b = 10);      //如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a, int b) 
{
	return a + b;
}

int main() 
{
	cout << "ret = " << func(20, 20) << endl;   //func(20, 20)表示a被赋值20，b被赋值20，c按照之前的默认值，输出结果是20+20+10=50
	cout << "ret = " << func(100) << endl;      //func(100)表示a被赋值100，b和c按照之前的默认值，输出结果是100+10+10=120
	cout << "ret = " << func(10,20,30) << endl; //func(10,20,30)表示a被赋值10，b被赋值20，c被赋值30，输出结果是10+20+30=60
	                                            //如果变量默认参数已有，调用的时候会被被传进来的数据更新
	system("pause");
	return 0;
}
/*
对上面的示例进行补充剖析：
*1. 如果参数列表中某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值。
例如：int func(int a, int b = 10, int c = 10) 
这里参数b有了默认参数了，那么参数c也必须要有默认参数，甚至于后面有d e的话等等都必须有默认值。
比如int func(int a, int b = 10, int c) 这样就是错误的  会报：默认实参不在形参列表的结尾。
比如这样int func(int a, int b, int c = 10)就是正确的。
*2. 如果函数声明有默认值，函数实现的时候就不能有默认参数。
示例：
int func2(int a = 10, int b = 10);  函数声明
int func2(int a, int b)             函数实体
{
	return a + b;
}
这样是正确的

上述的函数有函数实体和函数声明
如果函数声明中有了默认参数，那么在函数实体的形参中就不能有默认参数
就不能写成这样：
int func2(int a = 10, int b = 10);  函数声明
int func2(int a = 10, int b = 10)   函数实体
{
	return a + b;
}
这样是错误的，因为这样是  重定义了默认参数

哪怕声明和实体实现的时候默认参数不一样也不行
比如这样
int func2(int a = 10, int b = 10);  函数声明
int func2(int a = 20, int b = 20)   函数实体
{
	return a + b;
}
这样是错误的
因此声明和实体这两个部分 只能有一个部分 可以 拥有默认参数
*/

输出结果如下：

3.2 函数的占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法：返回值类型 函数名 (数据类型) { } //只写数据类型 不写变量名称 就是占位参数
在现阶段函数的占位参数存在意义不大，但是后面的课程中会用到该技术

#include "iostream"
using namespace std;

void func(int a, int)  //这里占位参数就是只写了数据类型，其实占位参数也可以有默认参数
{
	//为什么说现阶段用不到，因为我调用了该函数 如：func(10, 10); 
	//占位参数被赋值了10，但是我这个函数内部调用不了这个参数
	//因为我不知道这个参数名是什么，因此无法写这行代码
	cout << "this is func" << endl;
}

int main() 
{
	func(10, 10); //占位参数必须填补，也就是说占位参数被调用的时候，必须填上数据
	
	system("pause");
	return 0;
}
/*
对上面的示例进行补充剖析：
占位参数也可以有默认参数，比如创建函数的时候这样写
void func(int a, int = 10){}
那么调用的时候
func(10);即可
*/

输出结果如下：

3.3 函数重载-基本语法

作用：函数名可以相同，提高复用性
函数重载满足条件：
1.同一个作用域下； 比如定义都在全局 该函数不要在main函数中定义
2.函数名称相同；
3.函数参数类型不同 或者 参数个数不同 或者 参数顺序不同；

注意: 函数的返回值不可以作为函数重载的条件

#include "iostream"
using namespace std;

//函数重载需要函数都在同一个作用域下，这里示例的几个函数都定义在全局
void func()
{
	cout << "func 的调用！" << endl;
}
void func(int a)
{
	cout << "func (int a) 的调用！" << endl;
}
void func(double a)
{
	cout << "func (double a)的调用！" << endl;
}
void func(int a, double b)
{
	cout << "func (int a ,double b) 的调用！" << endl;
}
void func(double a, int b)
{
	cout << "func (double a ,int b)的调用！" << endl;
}

int main() 
{
	func();
	func(10);
	func(3.14);
	func(10, 3.14);
	func(3.14, 10);

	system("pause");
	return 0;
}
/*
对上面的示例进行补充剖析：
函数返回值不可以作为函数重载条件
int func(double a, int b)
{
	cout << "func (double a ,int b)的调用！" << endl;
	return 0;
}
上面已经定义了void func(double a, int b){}
这里又定义了  int  func(double a, int b){}
他们的区别仅在于 函数返回值的类型
这个区别是不能作为函数重载的条件的
你要么保留 void func(double a, int b)
要么保留   int  func(double a, int b)
两个函数是不能共存的
*/

输出结果如下：

3.4 函数重载-注意事项

1.引用作为重载条件
2.函数重载碰到函数默认参数

#include "iostream"
using namespace std;

//1、引用作为重载条件
void func(int& a)        //如果这里写成  void func(int& a = 10) 这是不合法的
{
	cout << "func (int &a) 调用 " << endl;
}
void func(const int& a)  //如果这里写成  void func(const int& a = 10) 这是合法的
{
	cout << "func (const int &a) 调用 " << endl;
}

//2、函数重载碰到函数默认参数
void func2(int a, int b = 10)
{
	cout << "func2(int a, int b = 10) 调用" << endl;
}
void func2(int a)
{
	cout << "func2(int a) 调用" << endl;
}

int main() 
{
	int a = 10;
	const int b = 10;
	
	func(a);       //调用无const的函数  原因就是a是一个变量 可读可写
	func(10);      //调用有const的函数  原因就是const 表述要传入一个常量
	func(b);       //调用有const的函数  原因就是const 表述要传入一个常量
	//func2(10);   //碰到默认参数产生歧义，需要避免

	system("pause");
	return 0;
}
/*
对上面的示例进行补充剖析：
int和const int在数据类型上是不同的，这里示例满足函数重载的条件之一：参数类型不同。
对于函数void func2(int a, int b = 10) 与 void func2(int a)而言
这样调用的话：func2(10);
这样编译器就不知道应该调用哪个函数了，产生了歧义，因此这种情况应该要避免
*/

输出结果如下：