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

 

C++中利用构造函数与无名对象简化运算符重载函数

　　在完整描述思想之前,我们先看一下如下的例子,这个例子中的加运算符重载是以非成员函数的方式出现的：

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

        {  
            Test::a = a;  

        }  
        friend Test operator + (Test&,int);  
    public:  

        int a;  
};  
Test operator + (Test &temp1,int temp2)  
{  
    Test result(temp1.a + temp2);  
    return result;  

}  
int main()  
{  

    Test a(100);  
    a = a + 10;//正确  
    a = 10 + a;//错误  

    cout<<a.a<<endl;  

    system("pause");  
}

上面的代码是一个自定义类对象与内置整型对象相加的例子，但错误行让我们猛然感觉很诧异，但仔细看看的确也在情理中，参数顺序改变后c++无法识别可供使用的运算符重载函数了。

　　我们为了适应顺序问题不得不多加一个几乎一样的运算符重载函数。

　　代码如下：

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

        {  
            Test::a = a;  

        }  
        friend Test operator + (Test&,int);  
        friend inline Test operator + (Test&,int);  
    public:  
        int a;  
};  

Test operator + (Test &temp1,int temp2)  
{  

    Test result(temp1.a + temp2);  
    return result;  
}  
inline Test operator + (int temp1,Test &temp2)//利用内联函数的定义提高效率  
{  
    return temp2+temp1;  
}  
int main()  
{  

    Test a(100);  
    a = a + 10;//正确  
    a = 10 + a;//正确  

    cout<<a.a<<endl;  

    system("pause");  
}

　　代码中我们使用内联函数的目的是为了缩减开销，但事实上我们仍然觉得是比较麻烦的，例子中的情况都还是非成员函数的情况，如果运算符重载函数是作为类成员函数，那么问题就来了，重载函数的第一个参数始终被隐藏，我们无发让int形参排列在隐藏参数的前面，从而导致a 
= 10 + a;无法获取正确的运算符重载函数。 




　　有问题的代码如下：
 

class Test    
{    
    public:    
        Test(int a)  

        {  
            Test::a = a;  

        }  
        Test operator + (int temp2)  
        {  

                Test result(temp1.a + temp2);  

                return result;  
        }  

        Test operator + ()//第一个参数被隐藏,怎么办????,int形参无法放到this指针的前面,理想中的应该是(int temp1,Test *this)  

        {  
  
        }  
    public:  

        int a;    
};

　　对于这个问题难道没有办法解决吗？ 
　　答案是否定的，我们可以利用类构造函数对参与运算的整型对象进行显式的类型转换，从而生成无名对象参与同类型对象的加运算，这样做可以缩减代码量，提高程序的可读性。 


　　代码如下（例一为非成员形式，例二为成员形式）：

//例一  
  
//程序作者:管宁        
//站点:www.cndev-lab.com        
//所有稿件均有版权,如要转载,请务必著名出处和作者     
  
#include <iostream>  
using namespace std;  
  
class Test    
{    
    public:    
        Test(int a)//事实上构造函数起的转换作用本质就是产生无名对象  

        {  
            Test::a = a;  

        }  
    friend Test operator + (Test&,Test&);  

    public:  
    int a;  

};  
Test operator + (Test &temp1,Test &temp2)  
{  

    Test result(temp1.a + temp2.a);  
    return result;  
}  
int main()  
{  
    Test a(100);  
    a = a + Test(10);//显式转换,产生无名对象  
    a = Test(10) + a;  
    cout<<a.a<<endl;  
    a = 50 + 1;//先进行50+1的内置整型的加运算，然后进行a=Test(51)的隐式转换  
    cout<<a.a<<endl;  
    system("pause");  

}

//例二  
  
//程序作者:管宁        
//站点:www.cndev-lab.com        
//所有稿件均有版权,如要转载,请务必著名出处和作者  
  
#include <iostream>  
using namespace std;  
  
class Test    
{    
    public:    
        Test(int a)//事实上构造函数起的转换作用本质就是产生无名对象  

        {  
                Test::a = a;  

        }  
        Test operator + (Test &temp)//第一个参数即使隐藏也没有关系,因为是以Test类型的无名对象参与运算的  
        {  

                Test result(this->a + temp.a);  
                return result;  
        }  
    public:  
        int a;  
};  

  
int main()  
{  

    Test a(100);  
    a = a + Test(10);  
    a = Test(10) + a;  
    cout<<a.a<<endl;  
    a = 50 + 1;//先进行50+1的内置整型的加运算，然后进行a=Test(51)的隐式转换  
    cout<<a.a<<endl;  
    system("pause");  

}

　　认真观察了上面的两个例子后我们可以发现，类的构造函数起了显式或者隐式转换的作用，转换过程实质是产生一个类的无名对象，类的运算符重载函数的参数就是这个无名对象的引用,所以参数的顺序也不再是问题，代码的运行效率也得到提高，无需再定义只是参数顺序不同，内容重复的运算符重载函数了。