C++之双目运算符重载

运算符重载可以友元重载，也可以成员函数重载，但两者是不能共存的。因为这会造成二义性，再一次强调，计算机最讨厌的就是让他做选择。同时有的运算符只支持友元重载，有的则只能成员函数重载，在后面的详细说明中，再区分，先举个例子：

一、友元重载：

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    friend Complex operator+(Complex &a, Complex &b){
        Complex t;
        t._x = a._x + b._x;
        t._y = a._y + b._y;
        return t;
    }
};

可以看到对于双目运算符重载的友元重载参数有两个，并且这里把友元的声明与定义都放在了类中，这样也是可以的。友元的实现位置不重要，但一定要在类中声明。

二、成员函数重载

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    Complex operator+(Complex &a){
        Complex t;
        t._x = this->_x + a._x;
        t._y = this->_y + a._y;
        return t;
    }
    friend Complex operator+(Complex &a, Complex &b){
        Complex t;
        t._x = a._x + b._x;
        t._y = a._y + b._y;
        return t;
    }
};

int main()
{
    Complex a(10, 0), b(20,0), c(30);
    a.dis();
    a = b + c;
    a.dis();
    return 0;
}

这里先把友元重载和成员函数重载放在一起，就会出现下面的错误：

也就是说产生了二义性，对于a = b + c;即可以是a = b.operator+(c);也可以是operator+(b, c)两种形式都可以实现，计算机要选择，那他就报告错误，说：臣妾做不到，必须只能给一个。或者把a = b + c;换成a = b.operator+(c);或者operator+(b, c)两种形式之一，那就知道调用哪个了，那么这里先把友元重载去掉：

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    Complex operator+(Complex &a){
        Complex t;
        t._x = this->_x + a._x;
        t._y = this->_y + a._y;
        return t;
    }
};

int main()
{
    Complex a(10, 0), b(20,0), c(30);
    a.dis();
    a = b + c;
    a.dis();
    return 0;
}

从刚才就可以看出，成员函数重载双目运算符的参数只有一个，那另一个呢，就是对象本身隐含着的this指针。对于普遍都可以使用友元重载和成员函数重载的运算符来说，这就是唯一的区别。

但这里有一个问题，对于这样一个运算：

int x = 10, y = 20, z = 30;
(x + y) = z;

系统是不允许这样运算的，运算符左边彻彻底底是个运算，这是不允许的，运算符左边只能是变量，但对于上面所做的运算符+重载，是可以编译通过的，这就未被了标准，老师常说的一句话：要成为好的程序员也一定要是好的测试员！（真的是很有道理的一句话啊），那这个地方就要这么改：

const Complex operator+(Complex &a){
        Complex t;
        t._x = this->_x + a._x;
        t._y = this->_y + a._y;
        return t;
    }

让返回值加上const限制，这样就不能被修改，自然也就不能充当左值了。

三、+=运算符重载
这里再举个+=的运算符重载例子，这是个比较经典的例子，同样分别用友元重载和成员函数重载来实现一下：

首先用友元重载来实现一下：

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    friend Complex& operator+=(Complex &a, Complex &b){
        a._x += b._x;
        a._y += b._y;
        return a;
    }
};

int main()
{
    int x = 10, y = 20, z = 30;
    x += y += z;
    cout << x << endl;
    cout << y << endl;
    cout << z << endl;

    cout << "------------------" << endl;

    Complex a(10, 0), b(20,0), c(30);
    a += b += c;
    a.dis();
    b.dis();
    c.dis();
    return 0;
}

结果是这样的：

结果很正确没有问题，但这里有一个重点需要说明一下，就是返回值类型的问题，这里为什么加上了引用，不加引用可不可以呢？
对于下面这语句是可以的：

a += b；

但对于

a += b += c;

就会报错，连等是从右往左运算的，先看b += c；运算完成之后返回的是一个complex类型的，然后再计算a += b;此时b是个complex类型，而参数要求是complex&类型，就会出现类型不匹配的错误，但仔细想想，b += c;中的c本身不也是complex类型，多加个引用也能算是类型不匹配，但编译器的的确确就是这么提示的错误：

这也是要建议的，对于带等号的运算符重载最好是用成员函数重载，友元重载这个错误还真不好解释。（以后有了新的解释再添加吧。）

我来添加了：问了老师之后，发现原来是不同的编译器的问题，老师是这么跟我解释的：各个编译器在这里严密程度不同。目前我是在qt上编译的，于是我换到vs2015编译了一下，果然没有再出错，我又换到codeblocks编译器上有运行一遍，悲催的是和qt一个错误，看来果然是编译器的问题，不过建议还是将返回类型改成complex&, 引用可以提高效率，并且能解决一些运算先后顺序的bug，下面用成员来实现时会说明其中一个bug。

接下来就用建议的成员来实现：

class Complex{
private:
    float _x;
    float _y;
public:
    Complex(float x = 0, float y = 0):_x(x), _y(y){}
    void dis(){
        cout << "( " << _x << "," << _y << " )" << endl;
    }
    Complex operator+=(const Complex &a){
        this->_x += a._x;
        this->_y += a._y;
        return *this;
    }
};

int main()
{
    int x = 10, y = 20, z = 30;
    x += y += z;
    cout << x << endl;
    cout << y << endl;
    cout << z << endl;

    cout << "------------------" << endl;

    Complex a(10, 0), b(20,0), c(30);
    a += b += c;
    a.dis();
    b.dis();
    c.dis();
    return 0;
}

结果跟友元重载一样是正确的，这里就不放截图了，注意一下这里的返回类型是complex，并没有加引用，那换一种运算：

int main()
{
    int x = 10, y = 20, z = 30;
    (x += y) += z;
    cout << x << endl;
    cout << y << endl;
    cout << z << endl;

    cout << "------------------" << endl;

    Complex a(10, 0), b(20,0), c(30);
    (a += b) += c;
    a.dis();
    b.dis();
    c.dis();
    return 0;
}

结果是这个样子滴：

显然结果错了，当时说明引用的时候解释过，如果返回的是类的类型，而不是类引用类型，那么系统会为最后的返回值会存储在临时变量上，当然会为这个临时变量开辟一段空间，返回到函数调用出，就会从存储临时变量的中间中取出值来，这个地方我们返回的是complex类型，对于

(a += b) += c;

先运算a += b；b加到了a上，但此时返回的已经是一个存储临时变量的空间，此时c就加到了这个存储临时变量的空间，并没有加到a上，所以a最终的值是30而不是60，所以应该这么改：

Complex& operator+=(const Complex &a){
        this->_x += a._x;
        this->_y += a._y;
        return *this;
    }

把返回值类型改成complex & 就可以了。结果如下：

这样结果就正确了。