C++中操作结构函数与无名工具简化运算符重载函数

副标题#e#

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

//措施作者:管宁
//站点: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;无法获取正确的运算符重载函数。

#p#副标题#e#

有问题的代码如下：

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");
}

#p#分页标题#e#

当真调查了上面的两个例子后我们可以发明，类的结构函数起了显式可能隐式转换的浸染，转换进程实质是发生一个类的无名工具，类的运算符重载函数的参数就是这个无名工具的引用,所以参数的顺序也不再是问题，代码的运行效率也获得提高，无需再界说只是参数顺序差异，内容反复的运算符重载函数了。