C++为函数提供的型特性——缺省参数与函数重载

一、缺省参数

二、函数重载

一、缺省参数

C++为函数提供了一项新的特性——缺省参数。缺省参数指的是当前函数调用中省略了实参自动使用的一个值。这极大地提高了函数的灵活性

缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调⽤该函数时，如果没有指定实参则采⽤该形参的缺省值，否则使⽤指定的实参
全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值
带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参
函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值

//缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值

//全缺省函数
void test(int x = 1, int y = 2, int z = 3);

//半缺省参数
void test(int x, int y, int z = 3);

对于一个带参数的函数，必须要从右向左依次添加缺省值。也就是说要为某个参数设置缺省值，必须为它的右边所有参数设在缺省值

//要为某个参数设置缺省值，必须为它的右边所有参数设在缺省值 
void test1(int x = 1, int y = 2, int z)//NO
{
	cout << x << " " << y << " " << z << endl;
}

//要为某个参数设置缺省值，必须为它的右边所有参数设在缺省值 
void test2(int x, int y = 2, int z)//NO
{
	cout << x << " " << y << " " << z << endl;
}

void test3(int x, int y = 2, int z = 3)//YES
{
	cout << x << " " << y << " " << z << endl;
}

void test4(int x = 1, int y = 2, int z = 3)//YES
{
	cout << x << " " << y << " " << z << endl;
}

带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参

//带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参
void test(int x, int y = 2, int z = 3)
{
	cout << x << " " << y << " " << z << endl;
}

int main()
{
	//带缺省参数的函数调⽤，必须从左到右依次给实参，不能跳跃给实参
	test(10);
	test(10, 100);
	test(10, 100, 1000);
	return 0;
}

下面是错误示范：

int main()
{
	//不能跳跃给实参
	test(10, , 1000);
	test(, , 1000);
	test(, 100,);
	return 0;
}

函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值

//函数声明
void test(int x = 1, int y = 2, int z = 3);

//函数定义
void test(int x, int y, int z)
{
	cout << x << " " << y << " " << z << endl;
}

下面是错误示范：

//缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值
//函数声明
void test(int x = 1, int y = 2, int z = 3);

//函数定义，这里不能个缺省值
void test(int x = 1, int y = 2, int z = 3)
{
	cout << x << " " << y << " " << z << endl;
}

缺省参数，并非编程方面的重大突破，而只是提供了一种便捷的方式。后面在我们设置类的时候，通过使用缺省参数，可以减少定义的构造函数和析构函数既方法重载的数量

二、函数重载

函数重载是C++在C语言的基础上新增的功能。缺省参数可以使我们能够使用不同数目的参数调用同一个函数，而函数重载可以使我们能够使用多个同名的函数

函数重载：

两个函数的参数数目不同，构成函数重载
两个函数的参数类型不同，构成函数重载
两个函数的参数类型顺序不同，构成函数重载
两个函数的返回值不同，不构成函数重载

两个函数的参数数目不同，构成函数重载

//两个函数的参数数目不同，构成函数重载 
void print(int x)
{
	cout << x << endl;
}

void print(int x, int y)
{
	cout << x << " " << y << endl;
}
int main()
{
	print(1);
	print(1, 2);
	return 0;
}

两个函数的参数类型不同，构成函数重载

【注意】

引用类型与类型本身视为同一个类型，不能构成函数重载

//两个函数的参数类型不同，构成函数重载 
void print(int x)
{
	cout << x << endl;
}

void print(double x)
{
	cout << x << endl;
}
int main()
{
	print(1);
	print(3.14);
	return 0;
}

//引用类型与类型本身视为同一个类型，不能构成函数重载
void print(int x)
{
	cout << x << endl;
}
int print(const int& x)
{
	return x;
}
int main()
{
	print(1);
	return 0;
}

两个函数的参数类型顺序不同，构成函数重载

//两个函数的参数类型顺序不同，构成函数重载 
void print(int x, double y)
{
	cout << x << " " << y << endl;
}

void print(double x, int y)
{
	cout << x << " " << y << endl;
}
int main()
{
	print(1, 3.14);
	print(3.14, 1);
	return 0;
}

两个函数的返回值不同，不构成函数重载

//两个函数的返回值不同，不构成函数重载
void add(int x, int y)
{
	cout << x + y << endl;
}
//会报错
int add(int x, int y)
{
	return x + y;
}
int main()
{
	add(1, 2);
	cout << add(1, 2) << endl;
	return 0;
}