考虑用赋值运算符(op=)取代其单独形式（op）(More Effective C++_22(效率))

　大多数程序员认为假如他们能这样写代码：

　　x = x + y; x = x - y;

　　那他们也能这样写：

　x += y; x -= y;

　　假如x和y是用户定义的类型（user-defined type），就不能确保这样。就C++来说，operator+、operator=和operator+=之间没有任何关系，因此假如你想让这三个operator同时存在并具有你所期望的关系，就必须自己实现它们。同理，operator -, *, /, 等等也一样。
　　
　　确保operator的赋值形式（assignment version）（例如operator+=）与一个operator的单独形式（stand-alone）(例如 operator+ )之间存在正常的关系，一种好方法是后者（指operator+ 译者注）根据前者（指operator+= 译者注）来实现（参见条款6）。
　　

 class Rational {
　　　public:
　　...
　　Rational& operator+=(const Rational& rhs);
　　Rational& operator-=(const Rational& rhs);
　　};
　　
　　
　　const Rational operator+(const Rational& lhs,const Rational& rhs)
　　{
　　　return Rational(lhs) += rhs;
　　}
　　
　　// operator- 根据 operator -= 来实现
　　
　　const Rational operator-(const Rational& lhs,const Rational& rhs)
　　{
　　　return Rational(lhs) -= rhs;
　　}

　
　　在这个例子里，从零开始实现operator+=和-=，而operator+ 和operator- 则是通过调用前述的函数来提供自己的功能。使用这种设计方法，只用维护operator的赋值形式就行了。而且假如假设operator赋值形式在类的public接口里，这就不用让operator的单独形式成为类的友元（参见Effective C++ 条款19）。
　　
　　假如你不介意把所有的operator的单独形式放在全局域里，那就可以使用模板来替代单独形式的函数的编写：
　　

 template<class T>
　　const T operator+(const T& lhs, const T& rhs)
　　{
　　　return T(lhs) += rhs; // 参见下面的讨论
　　}
　　
　　template<class T>
　　const T operator-(const T& lhs, const T& rhs)
　　{
　　　return T(lhs) -= rhs; // 参见下面的讨论
　　}
　　...

　　
　　使用这些模板，只要为operator赋值形式定义某种类型，一旦需要，其对应的operator单独形式就会被自动生成。
　　
　　这样编写确实不错，但是到目前为止，我们还没有考虑效率问题，效率究竟是本章的主题。在这里值得指出的是三个效率方面的问题。第一、总的来说operator的赋值形式比其单独形式效率更高，因为单独形式要返回一个新对象，从而在临时对象的构造和释放上有一些开销。operator的赋值形式把结果写到左边的参数里，因此不需要生成临时对象来容纳operator的返回值。
　　
　　第二、提供operator的赋值形式的同时也要提供其标准形式，答应类的客户端在便利与效率上做出折衷选择。也就是说，客户端可以决定是这样编写：
　　

 Rational a, b, c, d, result;
　　...
　　result = a + b + c + d; // 可能用了3个临时对象
　　// 每个operator+ 调用使用1个
　　还是这样编写：
　　
　　 result = a; //不用临时对象
　　result += b; // 不用临时对象
　　result += c; //不用临时对象
　　result += d; //不用临时对象

　　前者比较轻易编写、debug和维护，并且在80％的时间里它的性能是可以被接受的（参见条款16）。后者具有更高的效率，估计这对于汇编语言程序员来说会更直观一些。通过提供两种方案，你可以让客户端开发人员用更轻易阅读的单独形式的operator来开发和debug代码，同时保留用效率更高的operator赋值形式替代单独形式的权力。而且根据operator的赋值形式实现其单独形式，这样你能确保当客户端从一种形式切换到另一种形式时，操作的语义可以保持不变。
　　
　　最后一点，涉及到operator单独形式的实现。再看看operator+ 的实现：　

 template<class T>
　　const T operator+(const T& lhs, const T& rhs)
　　{ return T(lhs) += rhs; }

　　
　　表达式T(lhs)调用了T的拷贝构造函数。它建立一个临时对象，其值与lhs一样。这个临时对象用来与rhs一起调用operator+= ，操作的结果被从operator+.返回。这个代码似乎不用写得这么隐密。这样写不是更好么？
　　

 template<class T>
　　const T operator+(const T& lhs, const T& rhs)
　　{
　　　T result(lhs); // 拷贝lhs 到 result中
　　　return result += rhs; // rhs与它相加并返回结果
　　}

　　
　　这个模板几乎与前面的程序相同，但是它们之间还是存在重要的差别。第二个模板包含一个命名对象，result。这个命名对象意味着不能在operator+ 里使用返回值优化（参见条款20）。第一种实现方法总可以使用返回值优化，所以编译器为其生成优化代码的可能就会更大。
　　
　　主要的一点是operator的赋值形式（operator+=）比单独形式(operator+)效率更高。做为一个库程序设计者，应该两者都提供，做为一个应用程序的开发者，在优先考虑性能时你应该考虑考虑用operator赋值形式代替单独形式。

具体实现：

class Rational
{
public:
    Rational(int x,int y):a(x),b(y){
        cout<<"构造函数"<<endl;
    };
    ~Rational(){
        cout<<"析构函数"<<endl;
    };
    Rational(const Rational& rhs){
        this->a=rhs.a;
        this->b=rhs.b;
        cout<<"复制构造函数"<<endl;
    }
    Rational& operator+=(const Rational& rhs){
        this->a=this->a+rhs.a;
        this->b=this->b+rhs.b;
        return *this;

    }
    const Rational operator+(const Rational& rhs){
        **return Rational(*this)+=rhs;**//用operator+=实现
    }
    int ReturnA()const{return a;}
    int ReturnB()const{return b;}

    inline const Rational operator*(const Rational& rhs){
        return Rational(this->ReturnA()*rhs.ReturnA(),this->ReturnB()*rhs.ReturnB());
    }

    friend ostream& operator<<( ostream& os,const Rational& s){
        os<<s.a<<"/"<<s.b;
        return os;
    }
private:
    int a;
    int b;
};

---

参考：More Effective C++(侯捷译)