1、声明/定义重载函数时，是如何解决命名冲突的?(抛开函数重载不谈，using就是一种解决命名冲突的方法，解决命名冲突还有很多其它的方法，这里就不论述了)

2、当我们调用一个重载的函数时，又是如何去解析的?(即怎么知道调用的是哪个函数呢)

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

1、例子引入(现象)

什么是函数重载(what)?

为什么需要函数重载(why)?

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

函数重载为什么不考虑返回值类型

3、重载函数的调用匹配

模凌两可的情况

4、常量性与函数重载

5、总结

1、例子引入(现象)

1.1、什么是函数重载(what)?

函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。(不能根据返回值区分重载)

重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。

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

#include<iostream>  
using namespace std; void print(int i)  
{  
  cout<<"print a integer :"<<i<<endl;  
}   

void print(string str)  
{  
  cout<<"print a string :"<<str<<endl;  
}   

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、常量性与函数重载

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