複合賦值運算子

  形如‘*=’、‘+=’、‘/=’等這樣的運算子稱為複合賦值運算子，它們其實是算術運算和賦值運算的結合，即先執行算術運算，得到的值再賦值給左側物件。

過載複合賦值運算子：

1. 賦值運算子必須定義為類的成員，複合賦值運算子通常也應該定義為成員函式（但並不是必須這樣）。
2. 複合賦值運算子函式返回左側物件的引用（為了與內建的複合賦值運算子保持一致）。

下面是一個例子：

//過載了 += 運算子
#include<iostream>
using namespace std;

class Goods{
    public: 
        //建構函式     
 

        Goods(int x=0,double y=0.0){
            num = x;
            money = y;
        }
        //過載複合賦值運算子
        Goods   &operator+=(const Goods &gd2){
            num   += gd2.num;
            money += gd2.money;
            return *this;
        }
        //列印類的內容
        void print(){
            cout
 
<<num<<" "<<money<<endl;
        }

    private:
        int      num;
        double   money;
};

int main(){
    Goods       gd1(5,20);
    Goods       gd2(10,40);

    //將類gd2加到類gd1上
    gd1 += gd2;
    gd1.print();
    return 0;
}

過載算術運算子

   形如 +、-、*、/、等這類的是算術運算子。

1. 通常定義為非成員函式，這樣可以允許對左側或右側的運算物件進行轉換。例如： “hello”+string(“world”) 和 string(“hello”)+”world” 。
2. 形參一般是常量的引用，因為不需要改變運算物件的狀態。
3. 一般在函式內定義一個區域性變數儲存運算結果，函式返回該區域性變數的副本（見下面例子）。
4. 一般宣告為友元函式。
5. 一般過載了算術運算子，同時也會過載複合賦值運算子（此時，應注意程式碼複用原則，使用複合賦值運算子定義算術運算子，見下面例子）。

將上面的類加入算術運算子：

//過載了 += 和 +
#include<iostream>
using namespace std;

class Goods{
    public: 
        //建構函式     
        Goods(int x=0,double y=0.0){
            num = x;
            money = y;
        }
        //過載複合賦值運算子+=
        Goods   &operator+=(const Goods &gd2){
            num   += gd2.num;
            money += gd2.money;
            return *this;
        }
        //過載算術運算子+
        friend Goods  operator+(const Goods &gd1,const Goods &gd2);
        //列印類的內容
        void print(){
            cout<<num<<" "<<money<<endl;
        }

    private:
        int      num;
        double   money;
};

Goods operator+(const Goods &gd1,const Goods &gd2){
    Goods     tmp = gd1;   //定義一個區域性變數接收運算結果
    tmp += gd2;            //注意程式碼複用，使用已定義的複合賦值運算子
    return tmp; //返回區域性變數的副本
}

int main(){
    Goods       gd1(5,20);
    Goods       gd2(10,40);

    //將類gd1 與 gd2 相加
    (gd1 + gd2).print();
    return 0;
}

過載關係運算符

定義相等運算子

   類通過定義相等運算子來檢驗兩個物件是否相等，一般會比較物件的每一個數據成員，當所有對應的成員都相等是認為兩個物件相等。

設計準則：

1. 定義的相等運算子應該具有傳遞性，即若a==b 和 b==c都為真，則a==c為真。
2. 一般定義了==運算子，同時也應該定義 operator != 。此時，應注意程式碼複用，不需要重複定義（見下面例子）。
3. 一般定義為非成員函式。

//定義==和！=運算子 
#include<iostream>
#include<string>
using namespace std;

class Foo{
    public:
        Foo(int x=0,string s=""){
            num = x;
            name = s;
        }
friend  bool operator==(const Foo &f1,const Foo &f2);
friend  bool operator!=(const Foo &f1,const Foo &f2);
    private:
        int       num;
        string    name;
};

bool operator==(const Foo &f1,const Foo &f2){
    return f1.num == f2.num && f1.name == f2.name;
}

bool operator!=(const Foo &f1,const Foo &f2){
    //程式碼複用，使用定義好的==
    return !(f1==f2);
}

int main()
{
    Foo   f1(1,"liu");
    Foo   f2(1,"zhang");

    cout<<(f1 == f1)<<" "<<(f1 != f2)<<endl;
    return 0;
}

除此之外，我們還可以為類定義 > 、< 關係運算符。