C++学习——函数重载详解

以下内容源于C语言中文网的学习与整理，非原创，如有侵权请告知删除。

一、什么叫函数重载

简单地说，就是函数名相同，但参数列表不同。

在实际开发中，有时候我们需要实现几个功能类似的函数，只是有些细节不同。例如希望交换两个变量的值，这两个变量有多种类型，可以是 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 变量的值
void swap4(bool *a, bool *b); //交换 bool 变量的值

但在C++中没有必要这样做。C++ 允许多个函数拥有相同的名字，只要它们的参数列表不同就可以，这就是函数的重载（Function Overloading）。其中参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序。只要有一个不同就叫做参数列表不同。

借助重载，一个函数名可以有多种用途。比如借助函数重载交换不同类型的变量的值：

#include 
using namespace std;
 
//交换 int 变量的值
void Swap(int *a, int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}
 
//交换 float 变量的值
void Swap(float *a, float *b){
    float temp = *a;
    *a = *b;
    *b = temp;
}
 
//交换 char 变量的值
void Swap(char *a, char *b){
    char temp = *a;
    *a = *b;
    *b = temp;
}
 
//交换 bool 变量的值
void Swap(bool *a, bool *b){
    char temp = *a;
    *a = *b;
    *b = temp;
}
 
int main(){
    //交换 int 变量的值
    int n1 = 100, n2 = 200;
    Swap(&n1, &n2);
    cout<", "<
   
    //交换 float 变量的值
    float f1 = 12.5, f2 = 56.93;
    Swap(&f1, &f2);
    cout<", "<
   
    //交换 char 变量的值
    char c1 = 'A', c2 = 'B';
    Swap(&c1, &c2);
    cout<", "<
   
    //交换 bool 变量的值
    bool b1 = false, b2 = true;
    Swap(&b1, &b2);
    cout<", "<
 
    return 0;
}

本例之所以使用Swap这个函数名，而不使用swap，是因为C++标准库中已经提供了交还两个变量的值的函数，它的名字就是swap，位于algorithm头文件中。为了避免和标准库中的swap冲突，这里特地将字母s大写。

通过本利可以发现，重载就是在一个作用范围内（同一个类、同一个命名空间等）有多个名称相同但参数不同的函数。重载的结果是让一个函数名有了多种用途，使得命名更加方便（因为在中大型的项目中，给变量、函数、类起名字是一件让人苦恼的问题），调用更加灵活。

在使用重载函数时，同名函数的功能应当相同或相近，不要用同一函数名去实现完全不相干的功能，虽然程序也能运行，但可读性不好，使人觉得莫名其妙。

注意，参数列表不同包括参数的个数不同、类型不同或顺序不同，仅仅参数名称不同是不可以的。函数返回值也不能作为重载的依据。

函数的重载的规则：

• 函数名称必须相同。
• 参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。
• 函数的返回类型可以相同也可以不相同。
• 仅仅返回类型不同不足以成为函数的重载。

二、如何实现函数重载

C++代码在编译时会根据参数列表对函数进行重命名。

例如void Swap(int a, int b)会被重命名为_Swap_int_int；

例如void Swap(float x, float y)会被重命名为_Swap_float_float。

不同的编译器有不同的重命名方式，这里仅仅举例说明，实际情况可能并非如此。

当发生函数调用时，编译器会根据传入的实参的个数、类型、顺序等信息去逐个匹配，以选择对应的函数，如果匹配失败，编译器就会报错，这叫做重载决议（Overload Resolution）。从这个角度讲，函数重载仅仅是语法层面的，本质上它们还是不同的函数，占用不同的内存，入口地址也不一样。

三、二义性错误

发生函数调用时，编译器会根据传入的实参的个数、类型、顺序等信息，去匹配要调用的函数，这在大部分情况下都能够精确匹配。但当实参的类型和形参的类型不一致时，情况就会变得稍微复杂，例如函数形参的类型是int，调用函数时却将short类型的数据交给了它，编译器就需要先将short类型转换为int类型才能匹配成功。

下面都是在讨论“实参的类型和形参的类型不一致，导致二义性错误”的问题。

#include 
using namespace std;
 
//1号函数
void func(char ch){
    cout<<"#1"<
}
//3号函数
void func(long m){
    cout<<"#3"<
}
//4号函数
void func(double f){
    cout<<"#4"<
}
 
int main(){
    short s = 99;
    float f = 84.6;
  
    func('a');
    func(s);  //………………第22行
    func(49); //………………第23行
    func(f);
    return 0;
}

这段代码在编译时发生了错误，如下所示。大概的意思是：第22行的func(s)和第23行的func(49)这两个函数发生调用错误，它们可以匹配三个重载函数中的任何一个，编译器不知道如何抉择。 

C:\Users\XJH\Desktop>gcc 1.cpp -lstdc++
1.cpp: 在函数‘int main()’中:
1.cpp:22:11: 错误：调用重载的‘func(short int&)’有歧义
     func(s);
           ^
1.cpp:5:6: 附注：candidate: void func(char)
 void func(char ch){
      ^~~~
1.cpp:9:6: 附注：candidate: void func(long int)
 void func(long m){
      ^~~~
1.cpp:13:6: 附注：candidate: void func(double)
 void func(double f){
      ^~~~
1.cpp:23:12: 错误：调用重载的‘func(int)’有歧义
     func(49);
            ^
1.cpp:5:6: 附注：candidate: void func(char)
 void func(char ch){
      ^~~~
1.cpp:9:6: 附注：candidate: void func(long int)
 void func(long m){
      ^~~~
1.cpp:13:6: 附注：candidate: void func(double)
 void func(double f){
      ^~~~
 
C:\Users\XJH\Desktop>

根据以往经验，s 和 49 都应该被转换成 long 类型，从而匹配3号函数void func(long m)。但这种推论在一般的函数调用或者四则运算中确实没错，但它不一定适用于重载函数！

C++ 标准规定，在进行重载决议时编译器应该按照下面的优先级顺序来处理实参的类型：

注意，类型提升只有上表中列出的几种情况，其他情况都是类型转换。 

C++ 标准还规定，编译器应该按照从高到低的顺序来搜索重载函数：首先是精确匹配，然后是类型提升后匹配，最后才是类型转换后匹配；一旦在某个优先级中找到唯一的一个重载函数就匹配成功，不再继续往下搜索。

如果在一个优先级中找到多个（两个以及以上）合适的重载函数，编译器就会陷入两难境地，不知道如何抉择，编译器会将这种模棱两可的函数调用视为一种错误，因为这些合适的重载函数同等“优秀”，没有一个脱颖而出，调用谁都一样。

这就是函数重载过程中的二义性错误。

比如在上面例子中，func(s)、func(49)没有精确匹配的重载函数，将它们的类型都提升为 int 后仍然不能匹配，接下来进入自动类型转换阶段，发现 s 被转换为 char（整型转换）、long（整型转换）、double（整数和小数转换）后都有比较合适的函数，而且它们在同一个优先级中，谁也不比谁优秀，调用哪个都一样，产生了二义性，所以编译器会报错。

注意，类型提升和类型转换不是一码事！类型提升是积极的，是为了更加高效地利用计算机硬件，不会导致数据丢失或精度降低；而类型转换是不得已而为之，不能保证数据的正确性，也不能保证应有的精度。

再举一个例子说明。

假设现在有以下几个函数原型：

void func(int, int);  //1
void func(char, int, float);  //②
void func(char, long, double);  //③

我们来分析如下的调用会发生什么情况：

short n = 99;
func('@', n, 99);
func('@', n, 99.5);

函数原型func(int, int)只有两个参数，而函数调用有三个参数，很容易看出来不匹配，在初次筛选时就会被过滤掉，接下来我们只讨论第2、第3个函数原型。

（1）讨论func('@', n, 99);

如果只考虑第一个实参'@'，那么②③两个函数都能够精确匹配，谁也不比谁优秀，是平等的；

如果只考虑第二个实参n，对于②，需要把 short 提升为 int（类型提升），对于③，需要把 short 转换为 long（类型转换），类型提升的优先级高于类型转换，所以②胜出；

如果只考虑第三个实参99，②③都要进行类型转换，没有哪一个能胜出，它们是平等的。

从整体上看，②③在第一、三个实参的匹配中是平等的，但②在第二个实参的匹配中胜出，也就是说，②对每个实参的匹配都不劣于③，但有一个实参的匹配优于③，所以②最终脱颖而出，成为被调用函数。

（2）讨论func('@', n, 99.5);

如果只考虑第一个实参时，②③是平等的，没有谁胜出；

如果只考虑第二个实参时，对于②，需要把 short 提升为 int（类型提升），对于③，需要把 short 转换为 long（类型转换），类型提升的优先级高于类型转换，所以②胜出；

如果只考虑第三个实参时99.5，则②需要把 int 转换为float（类型转换），③能够精确匹配，精确匹配的优先级高于类型转换，所以③胜出。

从整体上看，②③在第一个实参的匹配中是平等的，②在第二个实参的匹配中胜出，③在第三个实参的匹配中胜出，它们最终“打成了平手”，分不清孰优孰劣，所以编译器不知道如何抉择，会产生二义性错误。