C++——函数重载详解
C++知识总结目录索引
1. 什么是重载
重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。
实际编程当中，有时候我们需要实现几个功能类似的函数，只是有些细节不同。例如Swap函数（用来交换两个变量的值），这两个变量有多种类型，可以是 int、float、char、bool 等，我们需要通过参数把变量的地址传入函数内部。如果是用C语言，我们要设计三个不同的函数，如下：
void Swap1(int *a, int *b); //交换 int 变量的值
void Swap2(float *a, float *b); //交换 float 变量的值
void Swap3(char *a, char *b); //交换 char 变量的值这样写起来非常麻烦，但在C++中我们完全没必要这么写，C++支持重载，多个函数可以有同一个名字，只要他们的参数列表不同。
参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同。
2. 重载的规则
函数的重载必须遵循以下四条规则：
- 函数名称必须相同。
- 参数列表必须不同（个数不同、类型不同、参数排列顺序不同，满足其一便可）。
- 函数的返回类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为函数的重载。
3. C++如何实现重载？
我们知道源代码(.cpp)翻译成可执行程序有四步——预处理、编译、汇编和链接。它们实现的功能是：
- 预处理：展开头文件、宏替换、去掉注释以及条件编译（#ifndef - #endif）。
- 编译：检查语法，生成汇编代码。
- 汇编：汇编代码转换成机器码。
- 链接：把目标文件和库文件链接成可执行文件。
C++代码在编译时会根据参数列表对函数进行重命名，下面展示一下在Linux操作系统的g++编译器中函数名的转换。
//交换两个int变量的值
void Swap(int *a, int *b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
//交换两个float变量的值
void Swap(float *a, float *b)
{
float tmp = *a;
*a = *b;
*b = tmp;
}
int main()
{
int n1 = 10;
int n2 = 100;
Swap(&a, &b);
float f1 = 1.1;
float f2 = 2.1;
Swap(&f1, &f2);
return 0;
} 用g++编译上述代码，然后使用objdump -d a.out > log.txt 把它的汇编代码写入到log.txt文件，再用less指令查看。我们来对比一下源代码中的函数名和汇编代码中的函数名：
void Swap(int* a, int* b) –> _Z4SwapPiS，
void Swap(float* x, float* y) –> _Z4SwapPfS。
通过比较我们推断出汇编代码的含义：作用域+(命名空间)+函数名+参数形式
在链接阶段，虽然代码中这几个函数名都是相同的，但是在编译系统作用下，这些函数已经根据C++函数名修饰规则重新生成了新的名字。
编译器会根据传入的实参去逐个匹配，以选择对应的函数，如果匹配失败，编译器就会报错，这叫做重载决议（OverloadResolution）。不同的编译器有不同的重命名方式，这里仅仅举例说明，实际情况可能并非如此。
问：在C++程序中调用被C编译器编译后的函数，为什么要加 extern "C" ？
答：C＋＋语言支持函数重载，C语言不支持函数重载。函数被C＋＋编译器编译和被C编译器编译后生成的内部名字是不同的。C++提供了C连接交换指定符号 extern "C" 来解决名字匹配问题（即二进制兼容性问题）。
C++之所以支持重载是因为它的函数名修饰规则。
4. 重载函数的调用匹配
先前说到编译器会根据传入的实参去逐个匹配，以选择对应的函数，那么它是如何匹配的呢？为了匹配到最适合的重载函数，需要依次按照下列规则来判断：
精确匹配：参数匹配而不做转换，或者只是做微不足道的转换，如数组名到指针、函数名到指向函数的指针、T到const T；
提升匹配：即整数提升（如bool 到 int、char到int、short 到int），float到double
使用标准转换匹配：如int 到double、double到int、double到long double、T* 到void*、int到unsigned int；
使用用户自定义匹配；
使用省略号匹配：类似printf中省略号参数
如果在最高层有多个匹配函数找到，调用将被拒绝（因为有歧义、模凌两可）。看下面的例子：
void func(short);
void func(long);
int main()
{
int i = 0;
func(i);
system("pause");
return 0;
}这时候就会报如下错误：
3 IntelliSense: 有多个 重载函数 "func" 实例与参数列表匹配:
函数 "func(short)"
函数 "func(long)"
参数类型为: (int)
错误 2 error C2668: “f2”: 对重载函数的调用不明确
错误 1 error C2668: “f1”: 对重载函数的调用不明确5. 运算符重载
在C++中可以用operator关键字加上运算符来表示函数，叫做运算符重载。运算符重载函数形式比较特殊，运算符本身就是函数名。
下面是一个复数相函数
Complex Add(const Complex& n1, const Complex& n2);
使用运算符重定义后：
Complex operator+(const Complex& n1, const Complex& n2);
使用方法：
int main()
{
Complex a, b, c;
//...
c = Add(a, b); //调用普通函数
c = a + b; //调用运算符重载函数——“+”
1. 运算符重载规则
| 运算符 | 规则 |
|---|---|
| 所有一元运算符 | 建议重载为非静态成员函数 |
=、()、[]、->、* |
只能重载为非静态成员函数 |
+=、-=、/=、*=、&=、/=、-=、%=、>>=、<<= |
建议重载为非静态成员函数 |
| 其他所有运算符 | 建议重载为全局函数 |
2. 运算符重载和函数重载的区别
- 如果重载为成员函数，则 this 对象发起对它的调用。
- 如果重载为全局函数，则第一个参数发起对它的调用。
- 除了函数调用运算符“()”外，其他运算符重载函数不能有默认参数值。
3. 不能重载的运算符
- 不能重载
.。 - 不能重载反引用类成员指针
.*。 - 不能重载作用域解析运算符
::。 - 不能重载唯一那个三元运算符——条件运算符
? :。 - 不能重载
sizeof()和typeid()。 - 不能重载
#和##等预处理操作符 。
4. 重载 ++ 和 --
在C++标准中规定：当为一个类型重载++或--的前置版本时，不需要参数；当为一个类型重载++或--的后置版本时，需要一个int类型的参数作为标志（即哑元，非具名参数），加这个int形参唯一的作用就是和前置版本构成重载。
class AA
{
public:
AA(int aa1, int aa2); //构造函数
AA(const AA& aa); //拷贝构造函数
AA& operator++(); //前置++
AA operator++(int); //后置++，形参列表不同才能构成重载
void Show();
private:
int _a1;
int _a2;
};
//重载实现
AA& AA::operator++() //前置
{
_a1 += 1;
_a2 += 1;
return *this;
}
AA AA::operator++(int) //后置
{
AA ret = AA(*this);
_a1 += 1;
_a2 += 1;
return ret;
}
//调用
int main()
{
AA aa(10, 11);
aa.operator++(); //调用前置++
aa.operator++(0); //调用后置++
aa.operator++(int()); //也可以这样写，调用后置++
system("pause");
return 0;
}我们比较上面代码的前置++和后置++实现，前置++实现只要对成员＋＋，然后直接返回就可了；但是后置++不同，后置++必须先保存原来的值，再进行++运算，最后返回，别小看这两者之间只差了一个创建变量，当你类成员非常大的时候，效率上的差距就出来了。
如果仔细看的话，你会发现前置++的返回值是引用，后置++返回的是值，返回值是要创建一个临时变量的，这样效率差距就更大了，所以如果可以，我们尽量使用前置++。
6. 输入输出运算符的重载
这部分看书时很少提到，提到了也都说输入输出运算符是不可以重载成成员函数的（都是用友元实现的），下面我们试着实现一下。
class AA
{
public:
//...
ostream& operator<<(ostream& os); //输入输出运算符的重载
istream& operator>>(istream& is);
private:
int _a1;
int _a2;
};
//类外实现
ostream& AA::operator<<(ostream& os)
{
os << _a1 << endl;
os << _a2 << endl;
return os;
}
istream& AA::operator>>(istream& is)
{
is >> _a1;
is >> _a2;
return is;
}
int main()
{
AA bb(1, 1);
cout << bb; //(1)
bb << cout; //(2)
system("pause");
return 0;
} 调用输入输出的时候我们发现按照常规写法 (1) ，程序会报错，报错的信息也很燃：错误 1 error C2679: 二进制“<<”: 没有找到接受“AA”类型的右操作数的运算符(或没有可接受的转换)。但当我们写成 (2) 这种形式时，程序是没问题的，可以正常运行。出现这种问题是因为this指针。
我们设计的函数是这样的ostream& operator<<(ostream& os);，但实际上是这样的ostream& operator<<(AA* this, ostream& os); this 指针已经强占了第一个形参的位置，但我们输入的是cout << bb，这样传参就弄反了，所以要写成bb << cout才能正确调用。
虽然上述代码我们已经基本实现输入输出运算符的重载了，但是这只是一个阉割版本，毕竟bb << cout这种写法是没人认可的，最重要的是这种写法没法实现连续输出的。所以想要完美实现还是得使用友元函数来实现。