Chinaunix首页 | 论坛 | 博客
  • 博客访问: 242247
  • 博文数量: 63
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 750
  • 用 户 组: 普通用户
  • 注册时间: 2015-05-10 21:59
  • 认证徽章:
个人简介

付出,终有回报!

文章分类

全部博文(63)

文章存档

2018年(6)

2017年(24)

2016年(6)

2015年(27)

分类: C/C++

2017-10-21 21:49:27

  • 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







阅读(447) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册