彻底理清重载函数匹配

前言

前面我们讲到了《什么是函数重载？》，有了函数重载之后，就需要确定某次调用需要选用哪个函数。这个过程可以称之为函数匹配或者重载确定。大多数情况下，我们都很容易能够确定某次调用需要选用哪个函数，但事实上不尽然。但通过本文将彻底理清重载函数匹配

匹配过程

为便于说明，将函数匹配分为三个阶段，确定候选函数，确定可行函数，确定最佳匹配函数。

确定候选函数

候选函数也就是和被调用的函数同名，并且其声明在调用点可见。举个简单的例子。 假设有两个文件，1.cpp和2.cpp，内容分别如下： 1.cpp：

//函数1
 void f(int a,short b)
 {
     cout<<"func0"<<endl;
 }

2.cpp：

 #include<iostream>
 using namespace std;
 //函数2
 void f(int a,double b)
 {
     cout<<"func1"<<endl;
 }
 //函数3
void f(int a, int b)
 {
     cout<< "func2"<<endl;
 }
 //函数4
 void f1()
 {
     cout<<"func3"<<endl;
 }
 int main()
 {
     f(3,4.5);
     return 0;
 }

在这里，候选函数其实只有两个，其中第一个函数在其调用点不可见，而第四个函数和被调用的函数不同名，因此这两个都不是候选函数。

确定可行函数

可行函数指的是本次调用传入的实参能够被候选函数使用。它要满足两个条件， 一是形参数量和实参数量相同，二是每个实参的类型和对应形参类型相同或者能够转换成形参的类型。

还是前面的例子，实参的个数和类型与第二个函数完全匹配，而在经过算术转换之后，也能够与第三个函数匹配。

确定最佳匹配函数

最佳匹配的函数是最终调用的。最佳匹配最基本的思想是认为，实参类型越接近，它们就越匹配。还是前面的例子，实参要与第三个函数匹配，需要进行算术转换，而与第二个函数完全匹配，因此第二个函数是最佳匹配函数。最终的运行结果如下：

 func1

最佳匹配原则

一般来说，精确匹配肯定比需要类型转换的匹配要更好，但是当形参有多个，并且无法完全精确匹配的时候，要确定最佳匹配函数就有点困难了。 但是有下面的原则：

• 函数的每个实参的匹配都不能比其他可行函数更差
• 函数至少有一个实参的匹配要比其他可行函数更好

那么问题又来了，什么是更好，什么又是更差呢？编译器将实参类型到形参类型的转换划分了等级：

• 1.精确匹配，包括实参类型和形参类型相同，实参从数组或函数转换成对应的指针类型，向实参添加顶层const或从实参删除顶层const
• 2.通过const转换实现的匹配
• 3.通过类型提升实现的匹配
• 4.通过算数类型转换实现的匹配
• 5.通过类类型转换实现的匹配

等级越靠前，匹配也就越好。接下来对上面的内容做一些解释。

精确匹配

精确匹配比较容易理解。关于顶层const问题，可以参考《什么是函数重载？》

通过const转换实现的匹配

所谓通过const转换实现的匹配，指的是通过加const限定词，能够与可行函数精确匹配。例如：

#include <iostream>
using namespace std;
//函数1
/*
int f(string &a)
{
    cout<<"call function 1"<<endl;
    return 0;
}*/
//函数2
int f(const string &a)
{
    cout<<"call function 2"<<endl;
    return 0;
}
int main()
{
    string test = "test";
    f(test);
    return 0;
}

在这里，test可以通过const转换，从而匹配函数2，将能够找到最佳匹配函数2（当前情况它也只有一个可选了）。 运行结果如下：

call function 2                                   

如果把函数1的注释去掉再运行，就会发现，虽然第一个调用既能匹配函数1，也能匹配函数2，但是由于匹配函数2的时候，需要const转换，因此比精确匹配要差，最终，它会调用函数1。 去掉函数1的注释后，运行结果如下：

call function 1                                      

通过类型提升实现的匹配

关于类型提升，这里不多做介绍。简单说明类型提升规则：

• float将提升到double
• char、short和相应的signed、unsigned类型将提升到int

我们来看一个示例：

#include <iostream>
using namespace std;
//函数1
/*
int f(short a)
{
    cout<<"call function 1"<<endl;
    return 0;
}*/
//函数2
int f(  int a)
{
    cout<<"call function 2"<<endl;
    return 0;
}
int main()
{
    short a = 2;
    f(a);
    return 0;
}

同样地，我们暂时把函数1注释掉。由于a是short类型，但是通过类型提升，可以转换为int，因为它也能调用函数2。运行结果如下：

call function 2

但去掉函数1注释后，由于精确匹配优于通过类型提升的匹配，因此将会调用函数1，运行结果如下：

call function 1

通过算术类型转换实现的匹配

short int和float，double等之间的转换，都是算术类型之间的转换。我们仍然来看一个例子：

#include <iostream>
using namespace std;
//函数1
int f(int a)
{
    cout<<"call function 1"<<endl;
    return 0;
}
//函数2
int f(double a)
{
    cout<<"call function 2"<<endl;
    return 0;
}
int main()
{
    short a = 2;
    f(a);
    return 0;
}

在这里，short类型的a既可以通过类型提升转换为int，也可以通过算术类型转换成为double。这个时候，哪个才是最佳匹配呢？我们看运行结果：

call function 1

对于这个结果，并不意外，因为前面我们已经说到，通过类型提升的转换是优于算术转换的，因而函数1是它的最佳匹配函数。

通过类类型转换实现的匹配

这里不多做介绍。我们也很容易理解。诸如父类和子类之间的转换都是如此。

二义性示例

前面基本能够找到最佳匹配，我们来看一个有多个可行函数，最后却没有最佳匹配的情况。

 #include<iostream>
 using namespace std;
 //函数1
 void f(double a,int b)
 {
     cout<<"function 1"<<endl;
 }
 //函数2
 void f(int a,double b)
 {
     cout<<"function 2"<<endl;
 }
 int main()
 {
     f(1,1);
     return 0;
 }

函数1和函数2都是可行函数，但它们都没有在任意一个参数上比对方更好，因此将会产生二义性，编译时将会报错：

error: call of overloaded ‘f(int, int)’ is ambiguous

总结

• 调用重载函数时，应当避免强制类型转换。
• 设计重载函数时应避免可能产生的二义性。
• 如果无法找到可行函数，编译器将报错。
• 设计重载函数的时候，希望避免需要用到上面的知识，而在定位问题时能够利用上面的知识很快定位问题。