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. 使用 SetParent 跨进程设置父子窗口时的一些问题(小心卡死)

    原文:使用 SetParent 跨进程设置父子窗口时的一些问题(小心卡死) 在微软的官方文档中,说 SetParent 可以在进程内设置,也可以跨进程设置.当使用跨进程设置窗口的父子关系时,你需要注意 ...

  2. openwrt luci web分析

    openwrt luci web分析 来源 https://www.jianshu.com/p/596485f95cf2 www/cbi-bin/luci #!/usr/bin/lua --cgi的执 ...

  3. 基于JMeter的Quick Easy FTP Server性能测试

    FTP性能测试 1.引言 1.1背景说明 本测试选用的是一个小型的FTP服务器软件:Quick Easy FTP Server.Quick Easy FTP Server是一个全中文的FTP服务器软件 ...

  4. 【转载】C#中使用List集合的Insert方法在指定位置插入数据

    在C#的List集合等数据类型变量中,我们可以使用List集合的Insert方法在指定的索引位置插入一个新数据,例如指定在List集合的第一个位置写入一个新数据或者在List集合的中间某个位置插入个新 ...

  5. windows下git创建本地分支并建立对应远程分支

    在对应项目目录下打开命令提示符 git branch -a      查看所有本地和远程分支 git checkout -b [newBranch]     建立本地分支newBranch git p ...

  6. day30-python之socket

    1.iter补充 # l=['a','b','c','d'] # # def test(): # return l.pop() # # x=iter(test,'b') # print(x.__nex ...

  7. MySQL Hardware--RAID级别查看

    MegaCli查看RAID级别: ## 查raid卡信息(生产商.电池信息及所支持的raid级别) /usr/local/sbin/MegaCli -AdpAllInfo -aALL |grep -E ...

  8. 【Java】锁机制

    参考 https://blog.csdn.net/varyall/article/details/79698145 <深入理解Java虚拟机> 锁状态:无锁.偏向锁.轻量级锁.重量级锁(具 ...

  9. java8 lamb表达式对List排序

    场景一:List<Long> 或其他泛型,非对象 List<Long> ids = new ArrayList(); ids.add(100000001L); ids.add( ...

  10. DevOps简介_转

    转自:DevOps简介     刘大飞 DevOps 是一个完整的面向IT运维的工作流,以 IT 自动化以及持续集成(CI).持续部署(CD)为基础,来优化程式开发.测试.系统运维等所有环节. Dev ...