C++函数重载

• 1、声明/定义重载函数时，是如何解决命名冲突的？（抛开函数重载不谈，using就是一种解决命名冲突的方法，解决命名冲突还有很多其它的方法，这里就不论述了）
• 2、当我们调用一个重载的函数时，又是如何去解析的？（即怎么知道调用的是哪个函数呢）

这两个问题是任何支持函数重载的语言都必须要解决的问题！带着这两个问题，我们开始本文的探讨。本文的主要内容如下：

•  1、例子引入（现象）
  • 什么是函数重载（what）？
  • 为什么需要函数重载（why）？
• 2、编译器如何解决命名冲突的?
  • 函数重载为什么不考虑返回值类型
• 3、重载函数的调用匹配
  • 模凌两可的情况
• 4、常量性与函数重载

• 5、总结

• 
  

1、例子引入（现象）

1.1、什么是函数重载（what）？

函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。（不能根据返回值区分重载）
重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。

看下面的一个例子，来体会一下：实现一个打印函数，既可以打印int型、也可以打印字符串型。在C++中，我们可以这样做：

#include
using namespace std; void print(int i)
{
        cout<<"print a integer :"<void print(string str)
{
        cout<<"print a string :"<int main()
{
        print(12);
        print("hello world!"); return 0;
}

通过上面代码的实现，可以根据具体的print()的参数去调用print(int)还是print(string)。

1.2、为什么需要函数重载（why）？

• （1）试想如果没有函数重载机制，如在C中，你必须要这样去做：为这个print函数取不同的名字，如print_int、print_string。这里还只是两个的情况，如果是很多个的话，就需要为实现同一个功能的函数取很多个名字，如加入打印long型、char*、各种类型的数组等等。这样做很不友好！
• （2）类的构造函数跟类名相同，也就是说：构造函数都同名。如果没有函数重载机制，要想实例化不同的对象，那是相当的麻烦！
• （3）操作符重载，本质上就是函数重载，它大大丰富了已有操作符的含义，方便使用，如+可用于连接字符串等！
• 
  

2、编译器如何解决命名冲突的?

为了了解编译器是如何处理这些重载函数的，我们反编译下上面我们生成的执行文件，我们在Linux下执行命令objdump -d a.out >log.txt反汇编并将结果重定向到log.txt文件中，然后分析log.txt文件。
我们可以发现编译之后，重载函数的名字变了不再都是原来的函数名！这样不存在命名冲突的问题了，但又有新的问题了——变名机制是怎样的，即如何将一个重载函数的签名映射到一个新的标识？
这个映射机制与编译器有关，在g++编译器下其规则为：“作用域+返回类型+函数名+参数列表”。

而在gcc中，其产生的函数符号仅由函数名决定。

既然返回类型也考虑到映射机制中，这样不同的返回类型映射之后的函数名肯定不一样了，但为什么不将函数返回类型考虑到函数重载中呢？
——这是为了保持解析操作符或函数调用时，独立于上下文（不依赖于上下文），看下面的例子

float sqrt(float); 

double sqrt(double); 

void f(double da, float fla)
{ 

 float fl=sqrt(da);//调用sqrt(double) 

 double d=sqrt(da);//调用sqrt(double)

  fl=sqrt(fla);//调用sqrt(float) 

  d=sqrt(fla);//调用sqrt(float) 

}

如果返回类型考虑到函数重载中，这样将不可能再独立于上下文决定调用哪个函数。

3、重载函数的调用匹配

现在已经解决了重载函数命名冲突的问题，在定义完重载函数之后，用函数名调用的时候是如何去解析的？为了估计哪个重载函数最适合，需要依次按照下列规则来判断：

• 精确匹配：参数匹配而不做转换，或者只是做微不足道的转换，如数组名到指针、函数名到指向函数的指针、T到const T；
• 提升匹配：即整数提升（如bool 到 int、char到int、short 到int），float到double
• 使用标准转换匹配：如int 到double、double到int、double到long double、Derived*到Base*、T*到void*、int到unsigned int；
• 使用用户自定义匹配；
• 使用省略号匹配：类似printf中省略号参数

如果在最高层有多个匹配函数找到，调用将被拒绝（因为有歧义、模凌两可）。看下面的例子：

void print(int); 

void print(const char*); 

void print(double);

void print(long); 

void print(char); 

void h(char c,int i,short s, float f)
{
     print(c);//精确匹配，调用print(char)

   print(i);//精确匹配，调用print(int)

     print(s);//整数提升，调用print(int) 

     print(f);//float到double的提升，调用print(double)

     print('a');//精确匹配，调用print(char) 

     print(49);//精确匹配，调用print(int) 

     print(0);//精确匹配，调用print(int)

     print("a");//精确匹配，调用print(const char*) 

}

定义太少或太多的重载函数，都有可能导致模凌两可，看下面的一个例子：

void f1(char);

void f1(long); 

void f2(char*);

void f2(int*); 

void k(int i)
{
    f1(i);//调用f1(char)？ f1(long)？ 

    f2(0);//调用f2(char*)？f2(int*)？ 

}

这时侯编译器就会报错，将错误抛给用户自己来处理：通过显示类型转换来调用等等（如f2(static_cast(0)，当然这样做很丑，而且你想调用别的方法时有用做转换）。上面的例子只是一个参数的情况，下面我们再来看一个两个参数的情况：

int pow(int ,int); 

double pow(double,double); 

void g()
{ 

 double d=pow(2.0,2)//调用pow(int(2.0),2)? pow(2.0,double(2))?

 }

3、常量性与函数重载

参数仅常量性不同是否可以重载？ 

不一定！成员函数的常量性不同可以重载；参数为引用时常量性不同可以重载；指针所指对象的常量性不同可以重载；只有传值参数以及指针本身的常量性不同时是不可以重载的。 　　 
　　以下情况，仅常量性不同的重载是合法的。

//成员函数的常量性不同，可以重载
class C {
public:
   void FuncA(int i);
    void FuncA(int i) const;
};

//参数类型为引用时，常量性不同可以重载
void FuncB(int& i);
void FuncB(const int& i);

//指针所指对象的常量性不同，可以重载
void FuncC(int *p);
void FuncC(const int *p);

成员函数的常量性可以认为是指针所指对象的常量性，当成员函数为const类型则说明调用该方法的类实例为const，相当于this指针为指向常量的指针。总结下来，引用和指针所指对象的常量性不同可以重载。(有些人将引用理解为指向对象的常量指针，这样一来剩下两种情况还可以进一步理解为：只有指针所指对象的常量性不同时可以重载。) 

以下情况，仅常量性不同不可以重载。

//传值调用形参常量性不同，不可以重载
void FuncD(int i);
void FuncD(const int i);

//指针本身的常量性不同，不可以重载
void FuncE(int *p);
void FuncE(int * const p);

实际上以上两种情况也可以归为一种。当我们使用传址调用（传指针）时，可以被看做是传递指针值的传值调用，指针自身的常量性不同不能重载。总结来看即为：非引用类型的参数本身的常量性不同不能重载。

那么，为什么非引用类型参数的常量性不同不能重载呢？C++的这样设计的道理何在？这还得从C语言说起，C++出于与C语言保持兼容的考虑，保留了C语言中的传值调用（参考Python、Java这些面向对象语言，他们根本没有这个概念，从C++的角度来看它们的函数调用都是引用传参）。而在传值调用过程中，由于函数内部总会在执行函数体之前复制一个实参副本，并在函数体内使用副本参与运算。这就导致实参本身（实参为指针时，指针所指对象就不一定不改变了。）在函数内部永远不会改变，函数返回时实参的值总是调用时实参的值。既然如此，那么实参是否为const类型根本无关紧要，即使不是const类型函数返回时也一定不会变。

　　相反地，引用和指针所指对象的常量性则显得很重要了！因为这些对象在函数内部是有可能被改变的。

总而言之，判断一组同名函数能否构成重载，要看能不能通过修改形参来影响实参的值，如果两个函数实参的值都能被修改或都不能被修改，则不能构成重载；否则构成重载。

参考：http://www.cnblogs.com/skynet/archive/2010/09/05/1818636.html
http://blog.csdn.net/qq_35280514/article/details/67675034