C++函数重载

 1. 概念：
                 同一个代码中，可以出现n个相同名字的函数
                 C++新增的语法点，C语言没有
       函数多态：多态从字面上理解就是多种表现形式
       作用：
                 同一个接口(函数名)，具备不同的表现形式，实现了接口的统一
                 比如：add --》大脑中的印象是加法运算
                               但是加法运算有很多表现形式啊
                                   两个整数相加  
                                   整数+小数     
                                   小数+小数     
                                   三个整数相加 
                                   ......

#include <iostream>  //C++特有的头文件  输入输出流头文件
#include <stdio.h>
using namespace std;  //先别管，照抄，

/*
	引出函数重载(function overload)
	   1.概念
	       C++允许程序员在同一个程序中定义多个名字相同的函数
		 好处
		   实现接口的统一，都是加法，你就不要搞那么多幺蛾子了，统一叫做add，方便记忆和理解
	   2.都叫add--》名字都一样，调用的时候如何区分
	     原理：编译器会依据你传递的实参类型，个数从左到右匹配调用对应的函数
	     
*/

int add(int n1,int n2)
{
	cout<<"int+int版本的add"<<endl;
	return n1+n2;
}
double add(double n1,double n2)
{
	cout<<"double+double版本的add"<<endl;
	return n1+n2;
}
double add(int n1,double n2)
{
	cout<<"int+double版本的add"<<endl;
	return n1+n2;
}

int main() 
{
	int n1=56;
	int n2=14;
	double n3=56.98;
	double n4=25.69;
	
	//add(n1,n2);  //匹配调用add(int,int)
	//add(n3,n4);  //匹配调用add(double,double)
	//add(n1,n3);  //匹配调用add(int,double)
	add(n3,n1);    //匹配调用add(double,int),没有这种版本的add，因此编译报错
	return 0;
}

    2. 原理：
                 编译器在编译程序的时候，会自动把函数替换(依据你传递的实参个数和类型，从左到右匹配)成对应版本重载形式

    3. 特点：
                 第一个： (重点，初学者很容易犯错)函数重载不关心返回值类型，返回值类型不同，其它的都一样(函数名字，参数个数类型)，不叫函数重载 
                 第二个： 函数重载，函数名必须相同
                 第三个： 函数重载，参数的个数或者类型至少要有一个是不同的 

#include <iostream>  //C++特有的头文件  输入输出流头文件
#include <stdio.h>
using namespace std;  //先别管，照抄，

/*
	函数重载的特点
	   1.不关心返回值类型
	     
*/

int add(int n1,int n2)
{
	cout<<"int+int有返回值版本的add"<<endl;
	return n1+n2;
}
void add(int n1,int n2)
{
	cout<<"int+int没有返回值版本的add  "<<n1+n2<<endl;
}

int main() 
{
	int n1=56;
	int n2=14;
	return 0;
}

    4. 参数类型的兼容性(一般情况下，我们自己写代码实现函数重载要求避免这种问题)
                参数是double类型，可以往下兼容float , int, long,short
                参数是float类型，可以往下兼容int, long,short
                long，short，int相互之间可以兼容(不区分精度)
                long,int,short和float之间可以互相兼容
                long,int,short和double之间可以互相兼容
       如果实参类型跟你定义函数形参类型完全匹配(一模一样)--》此时不必理会兼容性
       如果实参类型跟你定义函数形参类型不完全匹配(有差别)--》此时按照兼容性来处理，如果有多个版本可以兼容，编译器提示有歧义（二义性）

#include <iostream>  //C++特有的头文件  输入输出流头文件
#include <stdio.h>
using namespace std;  //先别管，照抄，明天上午告知你答案

/*
	函数重载参数的兼容性
	   1.有些同学理解函数重载的参数类型的时候，过于死板
*/

double add(double n1,double n2)
{
	cout<<"double+double有返回值版本的add"<<endl;
	return n1+n2;
}

int main() 
{
	int n1=56;
	int n2=14;
	float n3=56.9;
	float n4=23.6;
	
	add(n1,n2); //最优解  add(int,int),最优解不存在，退而求其次，选择add(double n1,double n2)
	add(n3,n4); //最优解  add(float,float),最优解不存在，退而求其次，选择add(double n1,double n2)
	add(n1,n3); //最优解  add(int,float),最优解不存在，退而求其次，选择add(double n1,double n2)
	return 0;
}

#include <iostream>  //C++特有的头文件  输入输出流头文件
#include <stdio.h>
using namespace std;  //先别管，照抄，明天上午告知你答案

/*
	如果有多个版本可以兼容，编译器报错
*/

double add(double n1,double n2)
{
	cout<<"double+double有返回值版本的add"<<endl;
	return n1+n2;
}
int add(int n1,int n2)
{
	cout<<"int+int有返回值版本的add"<<endl;
	return n1+n2;
}

float add(float n1,float n2)
{
	cout<<"float+float有返回值版本的add"<<endl;
	return n1+n2;
}

int main() 
{
	int n1=56;
	int n2=14;
	float n3=56.9;
	float n4=23.6;
	
	add(n1,n4); //最优解  add(int,float),最优解不存在，退而求其次
                //此时的"次"，有两个add(double n1,double n2)和add(int n1,int n2)
				//编译器报错，编译器傻了，不知道如何选择
	return 0;
}