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

http://pcedu.pconline.com.cn/empolder/gj/c/0503/587380.html

　　为什么需要转换运算符？

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

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

　　　operator 类名(); 

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

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

#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;  
        }  
        operator int()//转换运算符  
        {   cout<<this<<"："<<"载入转换运算符函数!"<<this->a<<endl;  
            return Test::a;  
        }  
    public:  
        int a;  
};  
int main(){  
    Test b(99);  
    cout<<"b的内存地址"<<&b<<endl;

    cout<<"--------"<<endl;   
    cout<<(int)b<<endl;//强转换  
    system("pause");  
}

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

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

#include <iostream>    
using namespace std;    
class Test{      
    public:  
        Test(int a = 0){  
            cout<<this<<"："<<"载入构造函数!"<<a<<endl;  
            Test::a = a;  
        }  
        Test(const Test &temp){  
            cout<<"载入拷贝构造函数!"<<endl;  
            Test::a = temp.a;  
        }  
        ~Test(){  
            cout<<this<<"："<<"载入析构函数!"<<this->a<<endl;  
        }  
        operator int(){  
            cout<<this<<"："<<"载入转换运算符函数的内存地址："<<this->a<<endl;  
            return Test::a;  
        }  
    public:  
    int a;  
};  
int main(){  
    Test a(50),b(100),c;  
    cout<<"a的内存地址"<<&a<<" | b的内存地址"<<&b<<endl;  
    c=Test((int)a+(int)b);//显示式转换 
	cout<<"----------"<<endl;
    c=a+b;//隐式转换  
    cout<<"c的内存地址"<<&c<<endl;  
    cout<<c.a<<endl;
	cout<<"---------"<<endl;  
    return 0;  
}

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

　　运行结果如下图示（注意观察内存地址，观察构造与析构过程）：

当一个类含有转换运算符重载函数的时候，有时候会破坏C++原有规则，导致运算效率降低，这一点不得不注意。         注意：这里没用到拷贝构造函数，因为拷贝构造函数只有三种情况：                      1、作为函数的参数（值传递）；2、作为函数的返回值；3、用已知对象去创建并初始化一个未建的对象。 　　示例如下：

#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;  
        }  
        operator int()//转换运算符,去掉则不会调用  
        {   cout<<this<<"："<<"载入转换运算符函数的内存地址："<<this->a<<endl;  
            return Test::a;  
        }  
    public:  
    int a;  
};  
int main(){  
    Test b=Test(99);//注意这里  
    cout<<"========="<<endl;
    cout<<"b的内存地址"<<&b<<endl;  
    cout<<b.a<<endl; 
	cout<<"----------"<<endl; 
    return 0;  
}

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

　　运行结果如下图所示

注意，这里如果把拷贝构造函数改成：

        Test(const Test &temp){  
            cout<<"载入拷贝构造函数!"<<endl;  
            Test::a = temp.a;  
        } 

结果就不一样了，原因不明。

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

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

#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;  
        }  
        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<<"============"<<endl;  
    cout<<"a的内存地址："<<&a<<" | b的内存地址："<<&b<<endl;  
    Test c=a+b;  
    cout<<"---------"<<endl;
    cout<<"c的内存地址："<<&c<<endl;  
    cout<<c.a<<endl;  
    cout<<"=============="<<endl;
    return 0;  
}

运行过程见下图

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

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

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

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

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

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

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

　　下例就是这个状态

#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));//显示的处理可以消除多义性问题  
    return 0;  
}

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

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

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