查看:4413|回复：12
如果我对单目运算符重载函数加入两个参数，编译器会报错提示参数过多。
下面的例子我在类Time里面加入了前置++运算符和后置++运算符的重载函数，代码如下：复制内容到剪贴板代码:#include &mxy.h&
class Time
& && &&&Time()
& && && && && & min=0;
& && && && && & sec=0;
& && &&&Time(int a,int b)
& && && && && & min=a;
& && && && && & sec=b;
& && &&&void display();
& && &&&Time operator++();
& && &&&Time operator++(int);
//dispaly函数定义
void Time::display()
& && &&&cout&&min&&&:&&&sec&&
//++运算符重载函数
Time Time::operator++()
& && &&&++
& && &&&if(sec&=60)
& && && && && & sec-=60;
& && && && && & ++
& && &&&return *
//后置++运算符重载函数
Time Time::operator++(int)& && && & //加入了一个参数
& && &&&Time t(*this);
& && &&&++
& && &&&if(sec&=60)
& && && && && & sec-=60;
& && && && && & ++
int main()
& && &&&Time time1,time2(3,60);
& && &&&time1.display();
& && &&&time2.display();
& && &&&for(i=0;i&60;++i)
& && && && && & time1++;
& && &&&for(i=0;i&60;++i)
& && && && && & time2++;
& && &&&time1.display();
& && &&&time2.display();
& && &&&return 0;
}在后置++运算符重载函数中我加入了一个int形参，加上Time类中的*This指针相当于加入了两个参数，却没有提示错误，这是为什么呢？知道的大侠帮忙解释下！~谢谢了！~
本帖最后由 poplaji 于
10:05 编辑
运算符重载，虽然是重定义运算符函数；
但是不能违背运算符原来的基本性质；
而++是一元操作符，即隐含的this指针；
而多出的Int只是为了区分前自增和后自增，并没有其他用处。
只有你爬到山顶了,这座山才会支撑着你。
引用:原帖由 月夜幻影 于
11:39 发表
运算符重载，虽然是重定义运算符函数；
但是不能违背运算符原来的基本性质；
而++是一元操作符，即隐含的this指针；
而多出的Int只是为了区分前自增和后自增，并没有其他用处。 ... 可是已经给出了一个·this的参数，再给出int参数相当于给了两个参数啊，如果把这个++运算符重载为两个友元函数，为了区分这个两个友元函数，在一个当中一个形参，另外一个加入任意两个形参，加入两个形参的一定会报错的。我就是这里不懂的:(
首先自增运算法被定义为类成员函数，并非友元。
另外除了函数嗲用操作符外，重载操作符的形参数目（包括成员函数的吟诗this指针）与操作符的操作数数目相同。函数调用操作符可以接受任意数目的操作符（c++primer 430页）
而这里的int只是为了区分其自增和后自增。
为了区分前缀是和后缀式操作符，后缀式操作符接受一个额外的int型形参，使用后缀式操作符是，编译器提供0作为这个形参的实参。
也就是说仅仅对于有前缀和后缀之分的操作符 才允许其中一个添加一个额外的形参以区分。
而目前接触过的这种操作符& &我目前就碰到过自增操作符。
只有你爬到山顶了,这座山才会支撑着你。
中级工程师
楼主你好，那个后知运算的int是一个标记符，作用是为了区分前自增和后自增，编译器会传递0作为后自增函数int形参的实参。引用:原帖由 poplaji 于
10:03 发表
如果我对单目运算符重载函数加入两个参数，编译器会报错提示参数过多。
下面的例子我在类Time里面加入了前置++运算符和后置++运算符的重载函数，代码如下：#include &mxy.h&
class Time
& && &&&Time()
& && && &...
The best of man is like water
Which benefits all things, and does not contend with them
Which flows in places that others disdain
Where it is in harmony with the Way
中级工程师
复制内容到剪贴板代码:/**
*&&参考 MSDN
*&&The prefix increment operator (++) add
*&&this incremented value is the result of the expression.
*&&The operand must be an l-value not of type const.
*&&The result is an l-value of the same type as the operand.
*&&The operands to postfix increment and postfix decrement
*&&operators must be modifiable (not const) l-values of arithmetic or pointer type.
*&&The type of the result is the same as that of the postfix-expression, but it is no longer an l-value
//以下示例仅供参考
#include&iostream&
#include&conio.h&
using std::
using std::
class Test{
& & Test(int i):_i(i){}
& & Test operator++(){ ++_i; return * }
& & const Test operator++(int){ Test tmp(_i); ++_i; }&&//后自增应该以pass by value方式返回，是右值
&&private:
& & int _i;
int main(int argc, char **argv){
&&Test test(1024);
&&//可以这样干，以确定这个形参只为区分而存在，无其他实际意义
&&test.operator++();
&&test.operator++(12);&&//编译器默认传递0，此参数只作为区分只用，你可以手动这样干，但并无实际意义。
&&return EXIT_SUCCESS;
}引用:原帖由 poplaji 于
10:03 发表
如果我对单目运算符重载函数加入两个参数，编译器会报错提示参数过多。
下面的例子我在类Time里面加入了前置++运算符和后置++运算符的重载函数，代码如下：#include &mxy.h&
class Time
& && &&&Time()
& && && &...
The best of man is like water
Which benefits all things, and does not contend with them
Which flows in places that others disdain
Where it is in harmony with the Way
引用:原帖由 月夜幻影 于
15:04 发表
首先自增运算法被定义为类成员函数，并非友元。
另外除了函数嗲用操作符外，重载操作符的形参数目（包括成员函数的吟诗this指针）与操作符的操作数数目相同。函数调用操作符可以接受任意数目的操作符（c++primer 430页）
而这里 ... 自增操作符也可以定义为友元函数的，只是你是否想破坏类的封装性而已；
c++primer书上的话我看了，我想问的是我这里重载了++操作符，++操作符是单目操作符，按理说我的形参应该是一个，但是放到类里面可以省略（因为指针this算作一个操作符，也就是括号里面说的），但是我为了区分前后自增操作符，再次重载这个操作符，并在函数的形参表里面加入了一个int类型，那么，重载操作符函数的形参应该变成了两个，一个是this的，一个是int，那么“重载操作符的形参数目（包括成员函数的吟诗this指针）与操作符的操作数数目相同”这句话就出现了问题。我的问题是这样的；
不过谢谢版主写了这么多，灰常感谢。
另外除了函数嗲用操作符外，重载操作符的形参数目（包括成员函数的吟诗this指针）与操作符的操作数数目相同。函数调用操作符可以接受任意数目的操作符（c++primer 430页）
为了区分前缀是和后缀式操作符，后缀式操作符接受一个额外的int型形参，使用后缀式操作符是，编译器提供0作为这个形参的实参
这两句的确有点相悖，C++本来就是在摸索中前行的；
就像定义类是为了封装数据；但却又引入了友元，友函数
也是自相矛盾的；
这个好像讨论也讨论不出结果的。最起码我是没这个能力了。
只有你爬到山顶了,这座山才会支撑着你。
引用:原帖由 Bill_Hoo 于
15:07 发表
楼主你好，那个后知运算的int是一个标记符，作用是为了区分前自增和后自增，编译器会传递0作为后自增函数int形参的实参。
那么这个标记符int我是否能理解为&&只有在单目运算符重载为成员函数时才可以用呢？
因为我尝试着把一个双目运算符重载为成员函数时，我正常来讲会只给一个形参，例如Complex Complex::operator+（Complex& c1)&&{...}& && &&&(Complex是一个表示复数的类）& & 我在这个形参表里面给出两个参数编译器会报错，提示参数个数不对。
引用:原帖由 月夜幻影 于
18:30 发表
另外除了函数嗲用操作符外，重载操作符的形参数目（包括成员函数的吟诗this指针）与操作符的操作数数目相同。函数调用操作符可以接受任意数目的操作符（c++primer 430页）
为了区分前缀是和后缀式操作符，后缀式操作符接受一个 ... 已经很感谢了！~~:lol& &&&又明白了单目运算符++的前置和后置重载函数是这样子的。
为了区分前缀是和后缀式操作符，后缀式操作符接受一个额外的int型形参，使用后缀式操作符是，编译器提供0作为这个形参的实参
只有这种情况下才可以添加额外的int形参
只有你爬到山顶了,这座山才会支撑着你。
引用:原帖由 月夜幻影 于
18:36 发表
为了区分前缀是和后缀式操作符，后缀式操作符接受一个额外的int型形参，使用后缀式操作符是，编译器提供0作为这个形参的实参
只有这种情况下才可以添加额外的int形参 ... 原来是区分前缀和后缀的，这次知道了，谢谢了！~
中级工程师
也可以用友元来做的，可能是你给的形参类型有误复制内容到剪贴板代码:#include &iostream&
class TIME
& && &&&TIME() : hour(0), min(0), sec(0){}
& && &&&TIME(int h, int m, int s) : hour(h), min(m), sec(s){}
& && &&&TIME(TIME &t)
& && && && && & sec = t.
& && && && && & min = t.
& && && && && & hour = t.
& && &&&~TIME(){}
& && &&&//const TIME& operator++()
& && &&&//{
& && &&&//& && &&&++
& && &&&//& && &&&int t = min + sec / 60;
& && &&&//& && &&&min = t % 60;
& && &&&//& && &&&hour = hour + t / 60;
& && &&&//& && &&&sec = sec % 60;
& && &&&//& && &&&return *
& && &&&//}
& && &&&//TIME operator++(int)
& && &&&//{
& && &&&//& && && &TIME tmp = *
& && &&&//& && && &++
& && &&&//& && && &int t = min + sec / 60;
& && &&&//& && && &min = t % 60;
& && &&&//& && && &hour = hour + t / 60;
& && &&&//& && && &sec = sec % 60;
& && &&&//& && && &
& && &&&//}
& && &&&friend TIME& operator++(TIME &t)
& && && && && & ++t.
& && && && && & int tmp = t.min + t.sec / 60;
& && && && && & t.sec = t.sec % 60;
& && && && && & t.min = tmp % 60;
& && && && && & t.hour = t.hour + tmp / 60;
& && && && && &
& && &&&friend TIME operator++(TIME &t, int)
& && && && && & TIME tt =
& && && && && & ++t.
& && && && && & int tmp = t.min + t.sec / 60;
& && && && && & t.sec = t.sec % 60;
& && && && && & t.min = tmp % 60;
& && && && && & t.hour = t.hour + tmp / 60;
& && && && && &
& && &&&friend ostream& operator&&(ostream& out, TIME &t)
& && && && && & out&&t.hour&&&:&&&t.min&&&:&&&t.sec&&
& && && && && &
int main(int argc, char **argv)
& && &&&TIME
& && &&&TIME tmp1;
& && &&&TIME tmp2;
& && &&&for(int i = 0; i & 3600; i++)
& && && && && & ++t;
& && &&&cout&&t;
& && &&&system(&pause&);
& && &&&return 0;
}至于成员函数的形参数目的问题，如斑竹所说纯粹是为了区分前缀式操作符和后缀式操作符。当然你也可以不重载后缀式操作符，那么t++也会调用重载的前缀式操作符，那么他的行为和++t无二样。但反过来你只重载后缀式操作符，那么++t就会出问题。> 问题详情
在重载一个运算符为成员函数时，其参数表中没有任何参数，这说明该运算符是A．后缀一元运算符B．前缀
悬赏：0&答案豆
提问人：匿名网友
发布时间：
在重载一个运算符为成员函数时，其参数表中没有任何参数，这说明该运算符是A．后缀一元运算符B．前缀一元运算符C．无操作数的运算符D．二元运算符请帮忙给出正确答案和分析，谢谢！
为您推荐的考试题库
您可能感兴趣的试题
1关于关键字class和typename,下列表述正确的是A．程序中所有的typename都可以替换为classB．程序中所有的class都可以替换为typenameC．A)和B)都正确D．A)和B)都不正确2有如下程序：　　　　　　　　#qnclude＜iostream＞　　　　　　　　#include＜iomanip＞　　　　　　　　using　namespace　　　　　　　　　class　CSum　　　　　　　　{　　　　int　x,y;　　　　　　　　public:　　　　　　　　CSum(int　x0,int　y0):x(xo),y(yo){}　　　　　　　　friend　ostream&　operator＜＜(ostream&os,const　CSum&xa)　　　　　　　　{　　　　os＜＜setw(5)＜＜Ka.k+xa.y;　　　　　　　　　　　　　return　　　　　　　　　}　　　　　　　　};　　　　　　　　int　main(){　　　　　　　　　　　　　CSum　y(3.5};　　　　　　　　　　　　　cout＜＜setfill('*')＜＜8　　　　　　　　　　　　　cout＜＜y;　　　　　　　　　　　　　return0;　　　　　　　　}　　　　执行上面程序的输出是A．88B．****88C．****8****8D．8****83有如下程序：　　　　　　　　#nclude＜iostremn＞　　　　　　　　using　namespace　　　　　　　　　class　Stack{　　　　　　　　public:　　　　　　　　Stack(unsigned　n=10:size(n){rep_=new　int[size];top=O;}　　　　　　　　Stack(Stack&s):size(s.size)　　　　　　　　{　　　　　　　　　　　　rep_=new　int[size];　　　　　　　　for(int　i=0;i＜i++)rep_[i]=s.rep_[i];　　　　　　　　top=s.　　　　　　　　}　　　　　　　　～Stack(){delete[]rep_;}　　　　　　　　void　push(int　a){rep_[top]=a;　top++;}　　　　　　　　int　opo(){--return　rep_[top];}　　　　　　　　bool　is　Empty()const{return　top==O;}　　　　　　　　pavate:　　　　　　　　　　　　int*rep_;　　　　　　　　　　　　unsigned　size,　　　　　　　　};　　　　　　　　int　main()　　　　　　　　{　　　　　　　　　　　　Stack　s1;　　　　　　　　　　　　for(int　i=1;i＜5;i++)　　s1.push(i);　　　　　　　　　　　　Stack　s2(s1);　　　　　　　　　　　　for(i=1;i＜3;i++)　　cout＜＜s2.pop()＜＜',';　　　　　　　　　　　　s2.push(6);　　　　　　　　　　　　s1.push(7);　　　　　　　　　　　　while(!s2.isEmpty())　　cout＜＜s2.pop()＜＜',';　　　　　　　　return　0；　　　　　　　　}　　　　执行上面程序的输出是A．4，3，2，1B．4，3，6，7，2，1C．4，3，6，2，1D．1，2，3，4
我有更好的答案
请先输入下方的验证码查看最佳答案
图形验证：
验证码提交中……
找答案会员
享三项特权
找答案会员
享三项特权
找答案会员
享三项特权
选择支付方式：
支付宝付款
郑重提醒：支付后，系统自动为您完成注册
请使用微信扫码支付(元)
支付后，系统自动为您完成注册
遇到问题请联系在线客服QQ：
请您不要关闭此页面,支付完成后点击支付完成按钮
遇到问题请联系在线客服QQ：
恭喜您！升级VIP会员成功
常用邮箱：
用于找回密码
确认密码：C++的函数重载 - 文章 - 伯乐在线
& C++的函数重载
—— 每个现象后面都隐藏一个本质，关键在于我们是否去挖掘
写在前面：
函数重载的重要性不言而明，但是你知道C++中函数重载是如何实现的呢（虽然本文谈的是C++中函数重载的实现，但我想其它语言也是类似的）？这个可以分解为下面两个问题
1、声明/定义重载函数时，是如何解决命名冲突的？（抛开函数重载不谈，using就是一种解决命名冲突的方法，解决命名冲突还有很多其它的方法，这里就不论述了）
2、当我们调用一个重载的函数时，又是如何去解析的？（即怎么知道调用的是哪个函数呢）
这两个问题是任何支持函数重载的语言都必须要解决的问题！带着这两个问题，我们开始本文的探讨。本文的主要内容如下：
1、例子引入（现象）
什么是函数重载（what）？
为什么需要函数重载（why）？
2、编译器如何解决命名冲突的?
函数重载为什么不考虑返回值类型
3、重载函数的调用匹配
模凌两可的情况
4、编译器是如何解析重载函数调用的？
根据函数名确定候选函数集
确定可用函数
确定最佳匹配函数
1、例子引入（现象）
1.1、什么是函数重载（what）？
函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。
When two or more different declarations are specified for a single name in the same scope,
that name is said to overloaded.
By extension, two declarations in the same scope that declare the same name but with different types are called overloaded declarations. Only function declaratio object and type declarations cannot be overloaded. ——摘自《ANSI C++ Standard. P290》
看下面的一个例子，来体会一下：实现一个打印函数，既可以打印int型、也可以打印字符串型。在C++中，我们可以这样做：
#include&iostream&
void print(int i)
cout&&"print a integer :"&&i&&
void print(string str)
cout&&"print a string :"&&str&&
int main()
print(12);
print("hello world!");
12345678910111213141516171819
#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)。上面print(12)会去调用print(int)，print(“hello world”)会去调用print(string)。
1.2、为什么需要函数重载（why）？
试想如果没有函数重载机制，如在C中，你必须要这样去做：为这个print函数取不同的名字，如print_int、print_string。这里还只是两个的情况，如果是很多个的话，就需要为实现同一个功能的函数取很多个名字，如加入打印long型、char*、各种类型的数组等等。这样做很不友好！
类的构造函数跟类名相同，也就是说：构造函数都同名。如果没有函数重载机制，要想实例化不同的对象，那是相当的麻烦！
操作符重载，本质上就是函数重载，它大大丰富了已有操作符的含义，方便使用，如+可用于连接字符串等！
通过上面的介绍我们对函数重载，应该唤醒了我们对函数重载的大概记忆。下面我们就来分析，C++是如何实现函数重载机制的。
2、编译器如何解决命名冲突的?
为了了解编译器是如何处理这些重载函数的，我们反编译下上面我们生成的执行文件，看下汇编代码（全文都是在Linux下面做的实验，Windows类似，你也可以参考《一道简单的题目引发的思考》一文，那里既用到Linux下面的反汇编和Windows下面的反汇编，并注明了Linux和Windows汇编语言的区别）。我们执行命令objdump -d a.out &log.txt反汇编并将结果重定向到log.txt文件中，然后分析log.txt文件。
发现函数void print(int i) 编译之后为：（注意它的函数签名变为——_Z5printi）
发现函数void print(string str) 编译之后为：（注意它的函数签名变为——_Z5printSs）
我们可以发现编译之后，重载函数的名字变了不再都是print！这样不存在命名冲突的问题了，但又有新的问题了——变名机制是怎样的，即如何将一个重载函数的签名映射到一个新的标识？我的第一反应是：函数名+参数列表，因为函数重载取决于参数的类型、个数，而跟返回类型无关。但看下面的映射关系：
void print(int i) –& _Z5printi
void print(string str) –& _Z5printSs
进一步猜想，前面的Z5表示返回值类型，print函数名，i表示整型int，Ss表示字符串string，即映射为返回类型+函数名+参数列表。最后在main函数中就是通过_Z5printi、_Z5printSs来调用对应的函数的：
80489bc: e8 73 ff ff ff call 8048934 &_Z5printi&
……………
80489f0: e8 7a ff ff ff call 804896f &_Z5printSs&
我们再写几个重载函数来验证一下猜想，如:
void print(long l) –& _Z5printl
void print(char str) –& _Z5printc
可以发现大概是int-&i，long-&l，char-&c，string-&Ss….基本上都是用首字母代表，现在我们来现在一个函数的返回值类型是否真的对函数变名有影响，如：
#include&iostream&
int max(int a,int b)
return a&=b?a:b;
double max(double a,double b)
return a&=b?a:b;
int main()
cout&&"max int is: "&&max(1,3)&&
cout&&"max double is: "&&max(1.2,1.3)&&
123456789101112131415161718
#include&iostream&using namespace std;&int max(int a,int b){&&&&&&&&return a&=b?a:b;}&double max(double a,double b){&&&&&&&&return a&=b?a:b;}int main(){&&&&&&&&cout&&"max int is: "&&max(1,3)&&endl;&&&&&&&&cout&&"max double is: "&&max(1.2,1.3)&&endl;&&&&&&&&return 0;}
int max(int a,int b) 映射为_Z3maxii、double max(double a,double b) 映射为_Z3maxdd，这证实了我的猜想，Z后面的数字代码各种返回类型。更加详细的对应关系，如那个数字对应那个返回类型，哪个字符代表哪重参数类型，就不去具体研究了，因为这个东西跟编译器有关，上面的研究都是基于g++编译器，如果用的是vs编译器的话，对应关系跟这个肯定不一样。但是规则是一样的：“返回类型+函数名+参数列表”。
既然返回类型也考虑到映射机制中，这样不同的返回类型映射之后的函数名肯定不一样了，但为什么不将函数返回类型考虑到函数重载中呢？——这是为了保持解析操作符或函数调用时，独立于上下文（不依赖于上下文），看下面的例子
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)
1234567891011
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)}
如果返回类型考虑到函数重载中，这样将不可能再独立于上下文决定调用哪个函数。
至此似乎已经完全分析清楚了，但我们还漏了函数重载的重要限定——作用域。上面我们介绍的函数重载都是全局函数，下面我们来看一下一个类中的函数重载，用类的对象调用print函数，并根据实参调用不同的函数：
#include&iostream&
class test{
void print(int i)
cout&&"int"&&
void print(char c)
cout&&"char"&&
int main()
t.print(1);
t.print('a');
12345678910111213141516171819202122
#include&iostream&using namespace std;&class test{public:&&&&&&&&void print(int i)&&&&&&&&{&&&&&&&&&&&&&&&&cout&&"int"&&endl;&&&&&&&&}&&&&&&&&void print(char c)&&&&&&&&{&&&&&&&&&&&&&&&&cout&&"char"&&endl;&&&&&&&&}};&int main(){&&&&&&&&test t;&&&&&&&&t.print(1);&&&&&&&&t.print('a');&&&&&&&&return 0;}
我们现在再来看一下这时print函数映射之后的函数名：
void print(int i) –& _ZN4test5printEi
void print(char c) –& _ZN4test5printEc
注意前面的N4test，我们可以很容易猜到应该表示作用域，N4可能为命名空间、test类名等等。这说明最准确的映射机制为：作用域+返回类型+函数名+参数列表。
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*)
123456789101112131415161718
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*)？
1234567891011
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&int *&(0)，当然这样做很丑，而且你想调用别的方法时有用做转换）。上面的例子只是一个参数的情况，下面我们再来看一个两个参数的情况：
int pow(int ,int);
double pow(double,double);
double d=pow(2.0,2)//调用pow(int(2.0),2)? pow(2.0,double(2))?
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))?}
4、编译器是如何解析重载函数调用的？
编译器实现调用重载函数解析机制的时候，肯定是首先找出同名的一些候选函数，然后从候选函数中找出最符合的，如果找不到就报错。下面介绍一种重载函数解析的方法：编译器在对重载函数调用进行处理时，由语法分析、C++文法、符号表、抽象语法树交互处理，交互图大致如下：
这个四个解析步骤所做的事情大致如下：
由匹配文法中的函数调用，获取函数名；
获得函数各参数表达式类型；
语法分析器查找重载函数，符号表内部经过重载解析返回最佳的函数
语法分析器创建抽象语法树，将符号表中存储的最佳函数绑定到抽象语法树上
下面我们重点解释一下重载解析，重载解析要满足前面《3、重载函数的调用匹配》中介绍的匹配顺序和规则。重载函数解析大致可以分为三步：
根据函数名确定候选函数集
从候选函数集中选择可用函数集合
从可用函数集中确定最佳函数，或由于模凌两可返回错误
4.1、根据函数名确定候选函数集
根据函数在同一作用域内所有同名的函数，并且要求是可见的（像private、protected、public、friend之类）。“同一作用域”也是在函数重载的定义中的一个限定，如果不在一个作用域，不能算是函数重载，如下面的代码：
void f(int);
void f(double);
f(1); //这里调用的是f(double)，而不是f(int)
void f(int);&void g(){&&&&&&&&void f(double);&&&&&&&&f(1); //这里调用的是f(double)，而不是f(int)}
即内层作用域的函数会隐藏外层的同名函数！同样的派生类的成员函数会隐藏基类的同名函数。这很好理解，变量的访问也是如此，如一个函数体内要访问全局的同名变量要用“::”限定。
为了查找候选函数集，一般采用深度优选搜索算法：
step1：从函数调用点开始查找，逐层作用域向外查找可见的候选函数
step2：如果上一步收集的不在用户自定义命名空间中，则用到了using机制引入的命名空间中的候选函数，否则结束
在收集候选函数时，如果调用函数的实参类型为非结构体类型，候选函数仅包含调用点可见的函数；如果调用函数的实参类型包括类类型对象、类类型指针、类类型引用或指向类成员的指针，候选函数为下面集合的并：
(1)在调用点上可见的函数;
(2)在定义该类类型的名字空间或定义该类的基类的名字空间中声明的函数;
(3)该类或其基类的友元函数;
下面我们来看一个例子更直观：
void f(int);
void f(double, double = 314);
names pace N
void f(char3 ,char3);
public: operat or double() { }
int main ( )
using names pace N; //using指示符
1234567891011121314151617
void f();void f(int);void f(double, double = 314);names pace N{ &&&&void f(char3 ,char3);}classA{&&&&public: operat or double() { }};int main ( ){&&&&using names pace N; //using指示符&&&&A a;&&&&f(a);&&&&return 0;}
根据上述方法，由于实参是类类型的对象，候选函数的收集分为3步：
(1)从函数调用所在的main函数作用域内开始查找函数f的声明， 结果未找到。到main函数
作用域的外层作用域查找，此时在全局作用域找到3个函数f的声明，将它们放入候选集合；
(2)到using指示符所指向的命名空间 N中收集f ( char3 , char3 ) ；
(3)考虑2类集合。其一为定义该类类型的名字空间或定义该类的基类的名字空间中声明的函
数；其二为该类或其基类的友元函数。本例中这2类集合为空。
最终候选集合为上述所列的 4个函数f。
4.2、确定可用函数
可用的函数是指：函数参数个数匹配并且每一个参数都有隐式转换序列。
(1)如果实参有m个参数，所有候选参数中，有且只有 m个参数；
(2)所有候选参数中，参数个数不足m个，当前仅当参数列表中有省略号；
(3)所有候选参数中，参数个数超过 m个，当前仅当第m + 1个参数以后都有缺省值。如果可用
集合为空，函数调用会失败。
这些规则在前面的《3、重载函数的调用匹配》中就有所体现了。
4.3、确定最佳匹配函数
确定可用函数之后，对可用函数集中的每一个函数，如果调用函数的实参要调用它计算优先级，最后选出优先级最高的。如对《3、重载函数的调用匹配》中介绍的匹配规则中按顺序分配权重，然后计算总的优先级，最后选出最优的函数。
本文介绍了什么是函数重载、为什么需要函数重载、编译器如何解决函数重名问题、编译器如何解析重载函数的调用。通过本文，我想大家对C++中的重载应该算是比较清楚了。说明：在介绍函数名映射机制是基于g++编译器，不同的编译器映射有些差别；编译器解析重载函数的调用，也只是所有编译器中的一种。如果你对某个编译器感兴趣，请自己深入去研究。
最后我抛给大家两个问题：
1、在C++中加号+，即可用于两个int型之间的相加、也可以用于浮点数数之间的相加、字符串之间的连接，那+算不算是操作符重载呢？换个场景C语言中加号+，即可用于两个int型之间的相加、也可以用于浮点数数之间的相加，那算不算操作符重载呢？
2、模板（template）的重载时怎么样的？模板函数和普通函数构成的重载，调用时又是如何匹配的呢？
附录：一种C++函数重载机制
这个机制是由张素琴等人提出并实现的，他们写了一个C++的编译系统COC++（开发在国产机上，UNIX操作系统环境下具有中国自己版权的C、C++和FORTRAN语言编译系统，这些编译系统分别满足了ISOC90、AT&T的C++85和ISOFORTRAN90标准）。COC++中的函数重载处理过程主要包括两个子过程：
1、在函数声明时的处理过程中，编译系统建立函数声明原型链表，按照换名规则进行换名并在函数声明原型链表中记录函数换名后的名字（换名规则跟本文上面描述的差不多，只是那个int-》为哪个字符、char-》为哪个字符等等类似的差异）
图附1、过程1-建立函数链表（说明，函数名的编码格式为：&原函数名&_&作用域换名&&函数参数表编码&，这跟g++中的有点不一样）
2、在函数调用语句翻译过程中，访问符号表，查找相应函数声明原型链表，按照类型匹配原则，查找最优匹配函数节点，并输出换名后的名字下面给出两个子过程的算法建立函数声明原型链表算法流程如图附1，函数调用语句翻译算法流程如图附2。
附-模板函数和普通函数构成的重载，调用时又是如何匹配的呢？
下面是C++创始人Bjarne Stroustrup的回答：
1)Find the set of function template specializations that will take part in overload resolution.
2)if two template functions can be called and one is more specified than the other, consider only the most specialized template function in the following steps.
3)Do overload resolution for this set of functions, plus any ordinary functions as for ordinary functions.
4)If a function and a specialization are equally good matches, the function is perferred.
5)If no match is found, the call is an error.
可能感兴趣的话题
有错误，Z后面的数字不是代表返回类型，是代表函数名的长度吧
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线内容团队正试图以我们微薄的力量，把优秀的原创文章和译文分享给读者，为“快餐”添加一些“营养”元素。
新浪微博：
推荐微信号
（加好友请注明来意）
– 好的话题、有启发的回复、值得信赖的圈子
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选文章
– UI,网页，交互和用户体验
– 专注iOS技术分享
– 专注Android技术分享
– JavaScript, HTML5, CSS
– 专注Java技术分享
– 专注Python技术分享
& 2017 伯乐在线