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

　　为什么需要转换运算符？

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

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

　　　operator 类名();

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

　　下面我看一个例子，看看它是如何工作的：

//例１ 
 
//程序作者:管宁         
//站点: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后，相加并创建临时类对象，后再赋给另一个对象。

　　代码如下：

//例２ 
 
//程序作者:管宁         
//站点: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++原有规则，导致运算效率降低，这一点不得不注意。

　　示例如下：

//例３ 
 
//程序作者:管宁         
//站点: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对象进行构造，可见中间的创建临时对象和载入转换运算符函数的过程完全是多余，读者对此例要认真解读，充分理解。

　　运行结果如下图所示（运行过程的解释见图）：

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

　　下面的例子就是这个情况，代码如下：

//例４ 
 
//程序作者:管宁         
//站点: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"); 
}

　　运行过程见下图。

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

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

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

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

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

　　类的转换构造函数与类的转换运算符重载函数是互逆的。（例３中的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. Django使用LDAP

    https://github.com/python-ldap/python-ldap Quick usage example: import ldap l = ldap.initialize(&quo ...

  2. 5G能带来什么改变-从鸿蒙OS说起

    背景 从5G投票事件开始,开始关注5G.许多文章都说到5G的特点有速度快.时延低,其中,时延低是最重要的特点.然而,时延低能给社会带来什么改变呢? 2G是短信的时代,3G促成了语音视频,4G促成了短视 ...

  3. dota2从窗口模式切换到独占全屏模式后黑屏解决办法

    在dota2安装目录中查找video.txt,修改setting.defaultres与setting.defaultresheight两个参数与显示器的分辨率相同. 修改setting.fullsc ...

  4. spark 机器学习 决策树 原理(一)

    1.什么是决策树 决策树(decision tree)是一个树结构(可以是二叉树或者非二叉树).决策树分为分类树和回归树两种,分类树对离散变量做决策树,回归树对连续变量做决策树. 其中每个非叶节点表示 ...

  5. nginx的压缩、https加密实现、rewrite、常见盗链配置

    Nginx 压缩功能 ngx_http_gzip_module #ngx_http_gzip_module 用gzip方法压缩响应数据,节约带宽 #启用或禁用gzip压缩,默认关闭 gzip on | ...

  6. zabbix 自动发现（LLD）

    概述 自动发现(LLD)提供了一种在计算机上为不同实体自动创建监控项,触发器和图形的方法.例如,Zabbix可以在你的机器上自动开始监控文件系统或网络接口,而无需为每个文件系统或网络接口手动创建监控项 ...

  7. js基础知识3

    系统对话框方法 警告框 window.alert('mcw'); 效果显示 确认框 var a = window.confirm('你确定要离开网站?'); console.log(a); 如果点击确 ...

  8. shell脚本——正则表达式

    什么是正则表达式 正则表达式分为基础正则和扩展正则,都是为了匹配符合预期要求的字符串 正则表达式与通配符的区别 只需要记住,对文件内容或是展示文本的操作都是正则,而对目录或文件名的操作则都是通配符(例 ...

  9. dns服务器正向解析配置

    DNS服务器的配置 一.安装软件 1.安装bind.bind-utils软件,起服务,设置开机启动. bind-utils软件用于提供nslookup功能,用于测试dns是否搭建成功,能够正常解析. ...

  10. Centos 7 SSH 无密码登录

    需求 本人使用CENTOS7进行开发调试,所以要经常通过 SSH 连接到服务器进行应用部署与维护.所以,迫切需要有一种方法能够免密码登录到云服务器,而且随处可用. 方案 使用"公私钥&quo ...