C++函数重载

一、函数重载概述

作用：函数名可以相同，提高复用性      

函数重载需要满足条件：

1.同一个作用域下

2.函数名称相同

3.函数参数类型不同或者参数个数不同或者参数顺序不同 

注意：函数的返回值不能作为函数重载的条件  

示例 ：同一个作用域下，函数名称相同，但参数类型、参数个数，顺序相同，运行失败

电脑并不知道调用哪个func()，所以出错。

示例 ：同一个作用域下，函数名称相同，参数个数不同，运行成功

调用第一个func函数

#include<iostream>
using namespace std;

//函数重载
//可以让函数名相同，提高函数的复用性

//函数重载满足的条件
//1、在同一个作用域下（例如func（）就都是在全局作用域下）
//2、函数名称相同
//3、函数的参数类型不同或者个数不同或者顺序不同
void func()
{
	cout << "func的调用" << endl;
}
void func(int a)  //不同的的参数类型
{
	cout << "func(int a)的调用!" << endl;
}
int main()
{
	func();
	
	return 0;
}

运行结果，运行成功 

调用第二个func函数

#include<iostream>
using namespace std;

//函数重载
//可以让函数名相同，提高函数的复用性

//函数重载满足的条件
//1、在同一个作用域下（例如func（）就都是在全局作用域下）
//2、函数名称相同
//3、函数的参数类型不同或者个数不同或者顺序不同
void func()
{
	cout << "func的调用" << endl;
}
void func(int a)  //不同的的参数个数
{
	cout << "func(int a)的调用!" << endl;
}
int main()
{
	//func();
	func(10);  //调用第二个func函数
	return 0;
}

 运行结果，运行成功   

示例 ：同一个作用域下，函数名称相同，参数类型不同，运行成功

调用第三个func函数

#include<iostream>
using namespace std;

//函数重载
//可以让函数名相同，提高函数的复用性

//函数重载满足的条件
//1、在同一个作用域下（例如func（）就都是在全局作用域下）
//2、函数名称相同
//3、函数的参数类型不同或者个数不同或者顺序不同
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函数     //参数个数不同
	func(3.14);  //调用第三个func函数     //参数类型不同

	return 0;
}

 运行结果，运行成功 

 示例 ：同一个作用域下，函数名称相同，参数顺序不同，运行成功

调用第四个func函数 

#include<iostream>
using namespace std;

//函数重载
//可以让函数名相同，提高函数的复用性

//函数重载满足的条件
//1、在同一个作用域下（例如func（）就都是在全局作用域下）
//2、函数名称相同
//3、函数的参数类型不同或者个数不同或者顺序不同
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函数     //参数个数不同
	//func(3.14);  //调用第三个func函数     //参数类型不同
	func(10, 3.14);  //调用第四个func函数  //参数顺序不同

	return 0;
}

  运行结果，运行成功    

 调用第五个func函数 

	#include<iostream>
	using namespace std;

	//函数重载
	//可以让函数名相同，提高函数的复用性

	//函数重载满足的条件
	//1、在同一个作用域下（例如func（）就都是在全局作用域下）
	//2、函数名称相同
	//3、函数的参数类型不同或者个数不同或者顺序不同
	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函数     //参数个数不同
		//func(3.14);  //调用第三个func函数     //参数类型不同
		//func(10, 3.14);  //调用第四个func函数  //参数顺序不同
		func(3.14, 10);    //调用第五个func函数  //参数顺序不同
		return 0;
	}

  运行结果，运行成功    

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

示例：产生歧义，编译器不知道调用哪个返回值类型的func函数 

二、函数重载的注意事项

 1.引用作为重载条件

示例 

#include<iostream>
using namespace std;
//函数重载的注意事项
//1、引用作为重载条件

//int &a和const int &a类型不同
void func(int& a)
{
	cout << "func(int &a)调用" << endl;
}

void func(const int& a)
{
	cout << "func(const	int &a)调用" << endl;
}
int main()
{
	int a = 10;

	func(a);  //调用没加const 的func();
	//原因：a本身是一个变量，变量可读可写可以修饰，加入const变成只读状态，只能读取不能写
	//所以正常创建变量会调用func(int &a);

	return 0;
}

 运行结果：调用的是func(int &a)

 示例

#include<iostream>
using namespace std;
//函数重载的注意事项
//1、引用作为重载条件

//int &a和const int &a类型不同
void func(int& a)   //int &a = 10 （常量区）不合法，引用必须要合法的内存空间（堆区）
{
	cout << "func(int &a)调用" << endl;
}

void func(const int& a)  //const int &a = 10 合法，加入const之后，编译器做了优化创建一个临时的数据，让a指向那块临时的空间
{
	cout << "func(const int &a)调用" << endl;
}
int main()
{
	int a = 10;

	//func(a);  //调用没加const 的func();
	//原因：a本身是一个变量，变量可读可写可以修饰，加入const变成只读状态，只能读取不能写
	//所以正常创建变量会调用func(int &a);

	func(10);  //调用加了const的func();

	return 0;
}

运行结果：调用func(const int &a);

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

 示例：正常调用

#include<iostream>
using namespace std;
//函数重载的注意事项
//2.函数重载碰到默认参数 

void func2(int a)
{
	cout << "func2(int a)的调用" << endl;
}

int main()
{
	func2(10);

	return 0;
}

 运行结果：

 示例：若有两段一样的func2函数 

#include<iostream>
using namespace std;
//函数重载的注意事项
//2.函数重载碰到默认参数 

void func2(int a)
{
	cout << "func2(int a)的调用" << endl;
}

void func2(int a)
{
	cout << "func2(int a)的调用" << endl;
}

int main()
{
	func2(10);

	return 0;
}

 运行结果：因为函数作用域，函数名相同，参数类型、个数、顺序均相同，所以会报错

示例：修改上例改变参数个数，则调用第二个func2函数运行成功

#include<iostream>
using namespace std;
//函数重载的注意事项
//2.函数重载碰到默认参数 

void func2(int a, int b)
{
	cout << "func2(int a, int b)的调用" << endl;
}

void func2(int a)
{
	cout << "func2(int a)的调用" << endl;
}

int main()
{
	func2(10);

	return 0;
}

 运行结果：因为函数作用域，函数名相同，参数个数不同，所以运行成功

示例：若给上例第一个func2函数默认值 ，注释调main函数里面对func2的调用，则没有问题

#include<iostream>
using namespace std;
//函数重载的注意事项
//2.函数重载碰到默认参数 

void func2(int a, int b = 10)
{
	cout << "func2(int a, int b)的调用" << endl;
}

void func2(int a)
{
	cout << "func2(int a)的调用" << endl;
}

int main()
{
	//func2(10);

	return 0;
}

 运行结果：

示例：若在上例main函数里调用func2  ，函数重载碰到默认参数，出现二义性，报错

 

 两个func2()都能调用，出现歧义，应尽量避免这种情况。写函数重载时尽量不要写默认参数。

 示例：若在上例main函数里调用func2 传入两个数 ，则正确

#include<iostream>
using namespace std;
//函数重载的注意事项
//2.函数重载碰到默认参数 

void func2(int a, int b = 10)
{
	cout << "func2(int a, int b)的调用" << endl;
}

void func2(int a)
{
	cout << "func2(int a)的调用" << endl;
}

int main()
{
	func2(10, 20);//传入两个参数没问题，不会出现二义性，此时调用第一个func2();

	return 0;
}

 运行结果：调用第一个func2

 三、函数重载总结

       C++语言中引进了重载函数，使得一个函数名可以对应不同的函数实现。重载函数存在着一些不同之处，系统将根据这些不同之处来选择对应的函数。这些不同之处表现在函数返回值类型、函数参数的类型、函数参数的个数和函数参数的顺序上。因此，在定义重载函数时，要在函数名相同的前提下，表现出参数上的不同来。

#include<iostream>
using namespace std;
//函数重载注意事项
//1、引用作为重载条件

void func(int& a)
{
	cout << "func(int &a)调用" << endl;
}

void func(const int& a)
{
	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;
	func(a);    //调用无const
	func(10);   //调用有const

	//func2(10);  //碰到默认参数出现歧义，需要避免。

	return 0;
}

运行结果