C++中那些令人蛋疼的带const形参的重载函数

发牢骚之前先温习一下重载函数的定义：出现在相同作用域中的两个函数，如果具有相同的名字而形参表不同，则称为重载函数。

根据教条主义，@.@~~哦，说错了，根据教材定义，如果有两个名字相同的函数，二者形参名字和类型都相同，但一个函数的形参带 const 修饰，而另一个函数不带 const 修饰，那么这两个函数应该也是重载函数。就像下面这两个版本：

//
// 版本 1 
//
int increase(int &val)
{
    return ++val;
}

//
// 版本 2
//
int increase(const int &val)
{
    return val + 1;
}

 没错，根据 IDE 编译证实，它们确实是重载函数，而且在使用上，版本 2 比版本 1 更加宽松。

当调用类似于版本 1 这样的函数（形参不是 const 引用）时，实参不可以带有 const 修饰，而且实参的和形参的类型必须一致，否则编译器会报错。而当调用类似于版本 2 这样的函数（形参为 const 引用）时，如果实参类型不匹配，函数将会进行尽可能类型转换，并创建一个无名的临时变量用来存储实参的值，并把形参作为该临时变量的引用。

为了更好地理解上面这段晦涩的说明，下面将给出演示代码：

#include <cstdlib>
#include <iostream>
using std::cout;
using std::endl;






    // cout << increase(1) << endl;         // 错误，1 不是引用.
    // cout << increase(sValue) << endl;    // 错误，sValue 不是 int 类型.
    cout << increase(iValue) << endl;       // 正确，类型精确匹配.
    // cout << increase(dValue) << endl;    // 错误，dValue 不是 int 类型.
    // cout << increase(sVALUE) << endl;    // 错误，sVALUE 不能为 const.
    // cout << increase(iVALUE) << endl;    // 错误，iVALUE 不能为 const.
    // cout << increase(dVALUE) << endl;    // 错误，dVALUE 不能为 const.

    return EXIT_SUCCESS;
}int main(void)
{
    short  sValue = 10;
    int    iValue = 20;
    double dValue = 30;
    const short  sVALUE = 40;
    const int    iVALUE = 50;
    const double dVALUE = 60.0;//
// 版本 1 
//
int increase(int &val)
{
    return ++val;
}

相比之下的版本 2 就爽了:

#include <cstdlib>
#include <iostream>
using std::cout;
using std::endl;






    // 看到了吧！一下代码全部通过编译.
    cout << increase(1) << endl;    
    cout << increase(sValue) << endl;    
    cout << increase(iValue) << endl;       
    cout << increase(dValue) << endl;
    cout << increase(sVALUE) << endl;
    cout << increase(iVALUE) << endl;
    cout << increase(dVALUE) << endl;

    return EXIT_SUCCESS;
}int main(void)
{
    short  sValue = 10;
    int    iValue = 20;
    double dValue = 30;
    const short  sVALUE = 40;
    const int    iVALUE = 50;
    const double dVALUE = 60.0;//
// 版本 2
//
int increase(const int &val)
{
    return val + 1;
}

版本 1 和版本 2 不同的原因在于，当函数调用时，实参与形参类型不同时，如果二者的类型能够进行隐式转换的话，会生成一个与形参类型相同的无名临时 const 对象，如果形参不是 const 的话，将会出错。

如果作用域是在一个类体中的话，那么还可以有重载版本 3 和重载版本 4，即 const 成员函数，如下：

class Clx
{
public :
    // 版本 1 
    int increase(int &val);
    
    // 版本 2 
    int increase(const int &val);


    


    // 版本 4 
    int increase(const int &val) const;
};// 版本 3
    int increase(int &val) const;

版本 3 和版本 4 是供带 const 的 Clx 类型对象调用，const 对象只能调用 const 版本的方法。

在上面，我故意忽略了两个版本，因为这两个版本比较蛋疼，如下：

//
// 版本 A
//
int increase(const int val)
{
    return val + 1;
}

//
// 版本 B
//
int increase(int val)
{
    return ++val;
}

为啥蛋疼呢？？因为它们看似重载却又不是重载，可是按道理它们又得是重载。C++的设计者也很蛋疼呀，没办法，这是历史遗留问题，为了跟 C 兼容，它们必须不重载，这就是人生，人生有时就是这么无奈。

在 C 语言里，版本 A 和版本 B 是没有区别的。如果这两个版本定义在相同的作用域中，C 编译器就会认为是函数重定义，而不是函数重载，因为 C 中根本就没有重载的概念。由于 C 中函数参数只有传值一种传递方式，因此 const 只是告诉编译器，形参在函数里面值是不可以被改变的。但是这已经跟实参没有任何关系了，传递进来的只不过是一个副本。与之不同的是 C++ 有引用，传引用会对实参造成影响。

PS: 写这篇文章本身就是件很蛋疼的事:<