C++ 如何判断所调用的重载函数

函数重载是C++的一个重要特性，但是函数重载后调用哪一个函数往往令人很困惑，参照《C++ Primer》第七章的内容总结如下：

---

 重载确定函数调用的步骤
1、候选函数(candidate function)
　　 1）、仅当形参是引用或指针时，形参是否为const 才有影响
　　 2）、不能基于指针本身是否为const 来实现函数重载
　　 3）、return 的类型不能用于判断重载

 2、可行函数
　　 1）、函数形参个数匹配(默认参数也是实参)
　　 2）、类型匹配，包含隐式转换的匹配
3、寻找最佳匹配
　　1）、精确类型匹配 > 需要转换的匹配
　　2）、通过类型提升的转换 > 其他标准转换

---

我还是喜欢用实际的例子来说明问题：

#include <iostream>
#include <cstdlib>

/*=================================================================*\
 *           
 *              重载确定函数调用的步骤
 *
 *                2013/6/5 by 樊列龙
 *
\*=================================================================*/

/*
 * 重载确定函数调用的步骤
 * 1、候选函数(candidate function)
 *      1）、仅当形参是引用或指针时，形参是否为const 才有影响
 *      2）、不能基于指针本身是否为const 来实现函数重载
 *      3）、return 的类型不能用于判断重载
 * 2、可行函数
 *      1）、函数形参个数匹配(默认参数也是实参)
 *      2）、类型匹配，包含隐式转换的匹配
 * 3、寻找最佳匹配
 *      1）、精确类型匹配 > 需要转换的匹配
 *      2）、通过类型提升的转换 > 其他标准转换
 */

using namespace std;


////////////////////////////////////////////////////
void funA(int &a, int &b)
{
    cout << "调用：funA(int &a, int &b)" << endl;
}

void funA(const int &a, const int &b)
{
    cout << "调用：funA(const int &a, const int &b)" << endl;
}


////////////////////////////////////////////////////
void funB(int *a, int *b)
{
    cout << "调用：funB(int *a, int *b)" << endl;
}
void funB(const int *a, const int *b)
{
    cout << "调用：funB(const int *a, const int *b)" << endl;
}

////////////////////////////////////////////////////
void f()
{
    cout << "调用：void f()" << endl;
}

void f(int )
{
    cout << "调用：void f(int )" << endl;
}

void f(int , int i = 1 )
{
    cout << "调用：void f(int , int )" << endl;
}

void f(double, double d = 1.0)
{
    cout << "调用：void f(double, double)" << endl;
}


///////////////////////////////////////////////////
void ff(short)
{
    cout << "调用：void ff(short)" << endl;
}
void ff(int)
{
    cout << "调用：void ff(int)" << endl;
}

///////////////////////////////////////////////////
void fff(long)
{
    cout << "调用：void fff(long)" << endl;
}
void fff(float)
{
    cout << "调用：void fff(float)" << endl;
}

int main()
{
    int a, b;
    const int ca = 0;
    const int cb = 0;

    funA(a,b);     // 调用：funA(int &a, int &b)
    funA(a,cb);    // 调用：funA(const int &a, const int &b)
    funA(ca,cb);   // 调用：funA(const int &a, const int &b)

    funB(&a,&b);   // 调用：funB(int *a, int *b)
    funB(&ca,&cb); // 调用：funB(const int *a, const int *b)
    funB(&a,&cb);  // 调用：funB(const int *a, const int *b)
    

    f(5.6);        // 调用：void f(double, double)
    //f(5);          // Error: 调用重载的‘f(int)’有歧义
    //f(5,6.0);      // 错误：调用重载的‘f(int, double)’有歧义
    f(static_cast<double>(5),6.0);// 调用：void f(double, double)
    f(5,static_cast<int>(6.0));   // 调用：void f(int , int )
    

    cout << "sizeof(short): " << sizeof(short) << endl;
    cout << "sizeof(char): " << sizeof(char) << endl;

    ff('a');                      // 调用：void ff(int)

    //double 既可以转换为long 也可以转换为 float，有二义性
    //fff(3.14);                    // 错误：调用重载的‘fff(double)’有歧义
    
    return EXIT_SUCCESS;
}

---

执行结果：

调用：funA(int &a, int &b)
调用：funA(const int &a, const int &b)
调用：funA(const int &a, const int &b)
调用：funB(int *a, int *b)
调用：funB(const int *a, const int *b)
调用：funB(const int *a, const int *b)
调用：void f(double, double)
调用：void f(double, double)
调用：void f(int , int )
sizeof(short): 2
sizeof(char): 1
调用：void ff(int)