C++运算符重载转换运算符

  为什么需要转换运算符?

大家知道对于内置类型的数据我们可以通过强制转换符的使用来转换数据,例如(int)2.1f;自定义类也是类型,那么自定义类的对象在很多情况下也需要支持此操作,C++提供了转换运算符重载函数,它使得自定义类对象的强转换成为可能。

  转换运算符的生命方式比较特别,方法如下:

   operator 类名();

  转换运算符的重载函数是没有返回类型的,它和类的构造函数,析构函数一样是不遵循函数有返回类型的规定的,他们都没有返回值

  下面我看一个例子,看看它是如何工作的:

//例1 
 
//程序作者:管宁         
//站点:www.cndev-lab.com         
//所有稿件均有版权,如要转载,请务必著名出处和作者      
   

#include <iostream>   
using namespace std;   
   

class Test     
{     
    public: 
        Test(int a = 0) 
        { 
            cout<<this<<":"<<"载入构造函数!"<<a<<endl; 

            Test::a = a; 
        } 

        Test(Test &temp) 
        { 
            cout<<"载入拷贝构造函数!"<<endl; 

            Test::a = temp.a; 
        } 

        ~Test() 
        { 
            cout<<this<<":"<<"载入析构函数!"<<this->a<<endl; 
            cin.get(); 
        } 
        operator int()//转换运算符 
        { 
            cout<<this<<":"<<"载入转换运算符函数!"<<this->a<<endl; 
            return Test::a; 
        } 
    public: 
        int a; 
}; 

int main() 


    Test b(99); 
    cout<<"b的内存地址"<<&b<<endl; 

    cout<<(int)b<<endl;//强转换 

    system("pause"); 
}

  在例子中我们利用转换运算符将Test类的对象强转换成了int类型并输出,注意观察转换运算符函数的运行状态,发现并没有产生临时对象,证明了它与普通函数并不相同,虽然它带有return语句。

  在很多情况下,类的强转换运算符还可以作为类对象加运算重载函数使用,尽管他们的意义并不相同,下面的例子,就是利用转换运算符,将两个类对象转换成int后,相加并创建临时类对象,后再赋给另一个对象。

  代码如下:

//例2 
 
//程序作者:管宁         
//站点:www.cndev-lab.com         
//所有稿件均有版权,如要转载,请务必著名出处和作者      
   

#include <iostream>   
using namespace std;   
   

class Test     
{     
    public: 
        Test(int a = 0) 
        { 
            cout<<this<<":"<<"载入构造函数!"<<a<<endl; 

            Test::a = a; 
        } 

        Test(Test &temp) 
        { 
            cout<<"载入拷贝构造函数!"<<endl; 

            Test::a = temp.a; 
        } 

        ~Test() 
        { 
            cout<<this<<":"<<"载入析构函数!"<<this->a<<endl; 
            cin.get(); 
        } 
        operator int() 
        { 

            cout<<this<<":"<<"载入转换运算符函数的内存地址:"<<this->a<<endl; 
            return Test::a; 
        } 
    public: 
    int a; 
}; 

int main() 


    Test a(100),b(100),c; 
    cout<<"a的内存地址"<<&a<<" | b的内存地址"<<&b<<endl; 
    c=Test((int)a+(int)b);//显示式转换 
    //c=a+b;//隐式转换 

    cout<<"c的内存地址"<<&c<<endl; 

    cout<<c.a<<endl; 

    system("pause"); 
}

  代码中的c=a+b;属于隐式转换,它的实现过程与c=Test((int)a+(int)b);完全相同。

  运行结果如下图示(注意观察内存地址,观察构造与析构过程,执行过程图中有解释):

  当一个类含有转换运算符重载函数的时候,有时候会破坏C++原有规则,导致运算效率降低,这一点不得不注意。

  示例如下:

//例3 
 
//程序作者:管宁         
//站点:www.cndev-lab.com         
//所有稿件均有版权,如要转载,请务必著名出处和作者      
   

#include <iostream>   
using namespace std;   
   

class Test     
{     
    public: 
        Test(int a = 0) 
        { 
            cout<<this<<":"<<"载入构造函数!"<<a<<endl; 

            Test::a = a; 
        } 

        Test(Test &temp) 
        { 
            cout<<"载入拷贝构造函数!"<<endl; 

            Test::a = temp.a; 
        } 

        ~Test() 
        { 
            cout<<this<<":"<<"载入析构函数!"<<this->a<<endl; 
            cin.get(); 
        } 
        operator int()//转换运算符,去掉则不会调用 
        { 
            cout<<this<<":"<<"载入转换运算符函数的内存地址:"<<this->a<<endl; 
            return Test::a; 
        } 
    public: 
    int a; 
}; 

int main() 


    Test b=Test(99);//注意这里 
    cout<<"b的内存地址"<<&b<<endl; 

    cout<<b.a<<endl; 

    system("pause"); 
}

  按照C++对无名对象的约定,Test b=Test(99);C++是会按照Test
b(99);来处理的,可是由于转换运算符的加入,导致这一规律被破坏,系统会“错误的”认为你是要给对象赋值,所以系统首先利用Test(99)创建一个临时对象用于赋值过程使用,可是恰恰系统又没有使用自动提供的赋值运算重载函数去处理,因为发现b对象并未构造,转而又不得不将开始原本用于赋值而创建的临时对象再次的强转换为int类型,提供给b对象进行构造,可见中间的创建临时对象和载入转换运算符函数的过程完全是多余,读者对此例要认真解读,充分理解。

  运行结果如下图所示(运行过程的解释见图):

  由于类的转换运算符与类的运算符重载函数,在某些地方上使用的时候,有功能相似的地方,如果两者都存在于类中,那么虽然运行结果正确,但其运行过程会出现一些意向不到的步骤,导致程序运行效率降低。

  下面的例子就是这个情况,代码如下:

//例4 
 
//程序作者:管宁         
//站点:www.cndev-lab.com         
//所有稿件均有版权,如要转载,请务必著名出处和作者      
   

#include <iostream>   
using namespace std;   
   

class Test     
{     
    public: 
        Test(int a = 0) 
        { 
            cout<<this<<":"<<"载入构造函数!"<<a<<endl; 

            Test::a = a; 
        } 

        Test(Test &temp) 
        { 
            cout<<"载入拷贝构造函数!"<<endl; 

            Test::a = temp.a; 
        } 

        ~Test() 
        { 
            cout<<this<<":"<<"载入析构函数!"<<this->a<<endl; 
            cin.get(); 
        } 
        Test operator +(Test& temp2) 
        { 

            cout<<this<<"|"<<&temp2<<"载入加运算符重载函数!"<<endl; 

            Test result(this->a+temp2.a);   

            return result;   
        } 

        operator int() 

        { 
            cout<<this<<":"<<"载入转换运算符函数的内存地址:"<<this->a<<endl; 
            return Test::a; 
        } 
    public: 
    int a; 
}; 

int main() 


    Test a(100),b(100); 
    cout<<"a的内存地址:"<<&a<<" | b的内存地址:"<<&b<<endl; 
    Test c=a+b; 

    cout<<"c的内存地址:"<<&c<<endl; 

    cout<<c.a<<endl; 

    system("pause"); 
}

  运行过程见下图。

  从图中我们可以清晰的看到,不必要的运算过程被执行,导致开销增大,读者在理解此例的时候要格外小心!

现在总结一下转换运算符的优点与缺点:

  优点:在不提供带有类对象参数的运算符重载函数的情况下,转换运算符重载函数可以将类对象转换成需要的类型,然后进行运算,最后在构造成类对象,这一点和类的运算符重载函数有相同的功效。(例2就是这种情况)

  缺点:如果一个类只有转换运算符重载函数,而没有真正意义上运算符重载函数,当用转换运算符重载函数替代运算符重载函数,进行工作的时候,就会让程序的可读性降低,歪曲了运算符操作的真正含义。(例2中的c=a+b;//隐式转换,就是例子,事实上a+b的作用只是对返回的整型数据进行了加运算,而对象赋值的操作是系统隐式的帮大家转换成了c=Test(a+b)。)

  最后我们来说一下,多路径转换的多义性问题,多义性问题一直是C++编程中容易忽视的问题,但它的确是不容小视,当问题隐藏起来的时候你不会发觉,一旦触发麻烦就来了。

  类的转换构造函数与类的转换运算符重载函数互逆的。(例3中的Test(int a =
0)是将int类型的数据转换构造成Test类对象,而operator int()则是将Test类对象转换成int类型数据)

  但是当他们是出现在两个不同的类中,对于一个类对象转换来说,同时拥有两种近似的转换途径的时候,多义性的问题就暴露出来,导致编译出错。

  下例就是这个状态:

//程序作者:管宁 
//站点:www.cndev-lab.com 
//所有稿件均有版权,如要转载,请务必著名出处和作者 
 
#include <iostream> 
using namespace std; 
class B; 

class A 

    public: 
        A(B &);//转换构造函数,他的作用是用B类对象构造A类对象 
        void Edita(int temp) 
        { 

            A::a=temp; 
        } 
    public: 
        int a; 
}; 

class B 

    public: 
        B(int a=0) 

        { 
            B::a=a; 
        } 
        int Ra() 
        { 
            return B::a; 
        } 
        operator A()//转换运算符重载函数,他的作用则是将B类对象转换成A类对象 
        { 

            return *this; 

        } 
    protected: 
        int a; 
}; 
A::A(B &temp) 

    cout<<this<<"|"<<&temp<<endl; 

    A::a=temp.Ra(); 

void tp(A temp) 


     

int main() 

    B bt(100); 
    A at=A(bt); 

    //tp(bt);//错误,多义性问题,系统不知道如何选择,是选择A(B &)转化构造好呢?还是选择B::operator A()进行转换好呢? 

    tp(A::A(bt));//显示的处理可以消除多义性问题 

    system("pause"); 
}

  代码中的A at=A(bt);运行正常,因为系统发现对象at还未构造,所以优先选取了A类的转换构造函数处理了,没有产生二义性问题。

  但是代码中的tp(bt);编译错误,这是因为函数tp的参数要求的是一个A类对象,而我们给他的则是一个B类对象,而在A类与B类中都有一个类似的操作,可以将B类对象转换成A类对象,系统不知道是选取A类的转换构造函数进行构造处理,还是选择B类中的转换运算符号重载函数处理,系统拒绝从他们两个中选一个,所以编译错误。

  我们修改tp(bt)为tp(A::A(bt));编译正常,因为我们显式的明确的告诉系统应该使用A类的转换构造函数处理,所以,显式的告诉计算机应该如何处理数据,通常可以解决多义性问题。

 
 

《挑战30天C++入门极限》C++运算符重载转换运算符的更多相关文章

  1. 《挑战30天C++入门极限》C++运算符重载赋值运算符

        C++运算符重载赋值运算符 自定义类的赋值运算符重载函数的作用与内置赋值运算符的作用类似,但是要要注意的是,它与拷贝构造函数与析构函数一样,要注意深拷贝浅拷贝的问题,在没有深拷贝浅拷贝的情况下 ...

  2. 《挑战30天C++入门极限》对C++递增(增量)运算符重载的思考

        对C++递增(增量)运算符重载的思考 在前面的章节中我们已经接触过递增运算符的重载,那时候我们并没有区分前递增与后递增的差别,在通常情况下我们是分别不出++a与a++的差别的,但的确他们直接是 ...

  3. 《挑战30天C++入门极限》C++中利用构造函数与无名对象简化运算符重载函数

        C++中利用构造函数与无名对象简化运算符重载函数 在完整描述思想之前,我们先看一下如下的例子,这个例子中的加运算符重载是以非成员函数的方式出现的: //程序作者:管宁  //站点:www.cn ...

  4. 《挑战30天C++入门极限》C++运算符重载函数基础及其值返回状态

        C++运算符重载函数基础及其值返回状态 运算符重载是C++的重要组成部分,它可以让程序更加的简单易懂,简单的运算符使用可以使复杂函数的理解更直观. 对于普通对象来说我们很自然的会频繁使用算数运 ...

  5. 《挑战30天C++入门极限》C++的iostream标准库介绍(3)

        C++的iostream标准库介绍(3) C语言提供了格式化输入输出的方法,C++也同样,但是C++的控制符使用起来更为简单方便,在c++下有两中方法控制格式化输入输出. 1.有流对象的成员函 ...

  6. 《挑战30天C++入门极限》C++的iostream标准库介绍(1)

        C++的iostream标准库介绍(1) 我们从一开始就一直在利用C++的输入输出在做着各种练习,输入输出是由iostream库提供的,所以讨论此标准库是有必要的,它与C语言的stdio库不同 ...

  7. 《挑战30天C++入门极限》C++面向对象编程入门:构造函数与析构函数

        C++面向对象编程入门:构造函数与析构函数 请注意,这一节内容是c++的重点,要特别注意! 我们先说一下什么是构造函数. 上一个教程我们简单说了关于类的一些基本内容,对于类对象成员的初始化我们 ...

  8. 《挑战30天C++入门极限》入门教程:实例详解C++友元

        入门教程:实例详解C++友元 在说明什么是友元之前,我们先说明一下为什么需要友元与友元的缺点: 通常对于普通函数来说,要访问类的保护成员是不可能的,如果想这么做那么必须把类的成员都生命成为pu ...

  9. 《挑战30天C++入门极限》C++类静态数据成员与类静态成员函数

        C++类静态数据成员与类静态成员函数 在没有讲述本章内容之前如果我们想要在一个范围内共享某一个数据,那么我们会设立全局对象,但面向对象的程序是由对象构成的,我们如何才能在类范围内共享数据呢? ...

随机推荐

  1. 让table中的td不会被过长的文字撑开,并且自动出现省略号

    <style type="text/css"> table {width:600px;table-layout:fixed;} td {white-space:nowr ...

  2. 前端开发 vue,angular,react框架对比2

    在过去一年里,前端开发发展迅速,前端工程师的薪资亦是水涨船高.2019 更是热度不减,而作为近年来尤为热门的前端框架,Vue.js 自是积累了大量关注.那么,Vue.js 是适合你的框架吗?     ...

  3. Java 之 web服务器—Tomcat

    一.服务器 1.服务器 服务器:安装了服务器软件的计算机 2.服务器软件 服务器软件:接收用户的请求,处理请求,做出响应 3.Web 服务器软件 web 服务器软件:接收用户的请求,处理请求,做出响应 ...

  4. Oracle 子查询(复杂select语句)

    在执行数据操作时,如果某个操作需要依赖于另外一个 select语句的查询结果,那么就可以把 select 语句迁入到该操作语句中,这样就形成了一个子查询.实际应用中,表与表之间相互关联,相互依存,这样 ...

  5. vue + elementui 使用多选按钮实现单选功能

    CommonRadio.vue <template> <div> <el-checkbox-group v-model="checkList" @ch ...

  6. Jmeter学习笔记(十六)——HTTP请求之content-type

    一.HTTP请求Content-Type 常见的媒体格式类型如下: text/html : HTML格式 text/plain :纯文本格式 text/xml : XML格式 image/gif :g ...

  7. Nginx的proxy buffer参数总结

    1. proxy_buffering 语法:proxy_buffering on|off 默认值:proxy_buffering on 上下文:http,server,location 作用:该指令开 ...

  8. 解决mysql跟php不在同一台机器上,编译安装php服务报错问题:configure: error: Cannot find MySQL header files under /application/mysql.

    在编译安装php服务时报错: configure: error: Cannot find MySQL header files under /application/mysql. Note that ...

  9. 逗号分隔的字符串转成表格参与IN条件查询

    返回值为'1,2,3,4,5,6,7',是一个字符串,如果要用IN 查询的话sql认为这是一个完整的字符串,需要将内容分隔转换变成table 定义函数如下: create Function sysfS ...

  10. altium designer(AD13)隐藏敷铜的方法

    覆铜,就是将PCB上闲置的空间作为基准面,然后用固体铜填充,这些铜区又称为灌铜.敷铜的意义在于,减小地线阻抗,提高抗干扰能力;降低压降,提高电源效率;还有,与地线相连,减小环路面积. 如果拿到别人的P ...