C++ 中的運算子多載

所謂重載，就是重新賦予新的含義。函數重載就是對一個已有的函數賦予新的含義，使之實現新功能。
運算子也可以重載 ..運算子多載是對已有的運算子賦予多重含義...

 

// 也就是說重載完之後，會根據我們定義的重載函數 自動調用最符合調用的方法使用...比如我們定義的類的重載運算子+. 當我們使用類的對象相加時，會自動調用我們定義的重載...而當我們使用內建的+法運算，比如 int b=5+3; 那麼這是還是調用內建的+法運算進行處理 ..

C++中預定義的運算子其運算對象只能是基礎資料型別 (Elementary Data Type)，而不適用於使用者自訂類型（如類）.

// 同上，內建的運算子 只能應用於內建的資料類型 ...比如 int char double .等等。

(一) C++不允許使用者自己定義新的運算子，只能對已有的C++運算子進行重載。

// 就是說只能重載內建的 + - * / 等運算子，不能自己創造運算子計算。 。

（二） C++允許重載的運算子C++中絕大部分的運算子允許重載.
不能重載的運算子只有5個：
(1) 成員訪問運算子.
(2) 範圍運算子∷
(3) 條件運算子?:
(4) 成員指標運算子*
(5) 編譯預先處理命令的開始符號#

(三) 重載不能改變運算子運算對象(即運算元)的個數。

// 不能改變運算子運算對象， 比如+法運算子，那麼它有兩個運算元 ..當我們重載它的時候 也只能有兩個運算元 。

(四) 重載不能改變運算子的優先順序別。

// 重載完之後並不能改變它的優先順序別，比如 +號， 無論你怎麼設計重載函數. 它永遠不可能比()的優先順序高......
(五) 重載運算子的函數不能有預設的參數，否則就改變了運算子參數的個數，與前面第(3)點矛盾。

// 於上面3..同。

(六) 重載的運算子必須和使用者定義的自訂類型的對象一起使用，其參數至少應有一個是類對象(或類對象的引用)。也就是說，參數不能全部是C++的標準類型，以防止使用者修改用於標準類型資料的運算子的性質。

// 重載的參數不能全部是C++內建資料類型。 至少要有一個是自訂類型。因為如果我們定義的是兩個內建的類型 就會跟系統所定義的衝突。 因為當我們使用內建的運算子時，那麼編譯器其實也是調用的一個重載運算子進行計算。這是編譯器自動添加的。 如果我們也定義的相同 那麼肯定會產生衝突。

(七) 用於類對象的運算子一般必須重載，但有兩個例外，運算子“=”和“&”不必使用者重載。
① 賦值運算子(=)可以用於每一個類對象，可以利用它在同類對象之間相互賦值。
② 地址運算子&也不必重載，它能返回類對象在記憶體中的起始地址。

// 前面已經說過，C++內建運算子只能計算內建的資料類型 。所以當我們要使用自訂類型時 就必須要進行重載..

總之，當C++語言原有的一個運算子被重載之後，它原先所具有的語義並沒有消失，只相當於針對一個特定的類定義了一個新的運算子。
運算子多載可以使用成員函數和友元函數兩種形式。可以參考以下的經驗：
(1)只能使用成員函數重載的運算子有：=、()、[]、->、new、delete。
(2)單目運算子最好重載為成員函數。
(3) 對於複合的賦值運算子如+=、-=、*=、/=、&=、!=、~=、%=、>>=、<<=建議重載為成員函數。
(4) 對於其它運算子，建議重載為友元函數。
運算子多載的方法是定義一個重載運算子的函數，在需要執行被重載的運算子時，系統就自動調用該函數，以實現相應的運算。也就是說，運算子多載是通過定義函數實現的。運算子多載實質上是函數的重載。重載運算子的函數一般格式如下：
函數類型 operator 運算子名稱 (形參表列)
{
   對運算子的重載處理
}
重載為類成員函數時參數個數=原運算元個數-1
（後置++、--除外）

// 當重載為類成員函數時，參數個數等於原來的運算元-1 ..比如 對象a +對象b ..我們重載的時候需要兩個運算元 a 和b 但我們傳遞過去一個就可以了 ， 比如 a+b 我們只需要把b傳遞過去就可以了。因為當調用重載運算子時 就是a調用的重載運算子，那麼它就是當前對象 它就是這時的this 指標 ..而且類成員函數只能使用兩個類中成員...

重載為友元函數時 參數個數=原運算元個數，且至少應該有一個自訂類型的形參。

//與上面沒多大區別，但它卻可以調用非類中對象.. 比如調用一個對象a+1 ..注意的是即使定義為友元函數，它的運算元也必須有一個為自訂類型。

 

看一個執行個體：

#include<iostream>
using namespace std;
class complex //複數類聲明
{
public: //外部介面
complex(double r=0.0,double i=0.0)
{
    real=r;
    imag=i;
   } //建構函式
complex operator + (complex c2); //+重載為成員函數
complex operator - (complex c2); //-重載為成員函數
void display(); //輸出顯示複數
private: //私人資料成員
double real; //複數實部
double imag; //複數虛部
};
complex complex::operator +(complex c2) //重載函數實現
{
complex c;
c.real=real+c2.real;
c.imag=imag+c2.imag;
return complex(c.real,c.imag);
}
complex complex::operator -(complex c2) //重載函數實現
{
complex c;
c.real=real-c2.real;
c.imag=imag-c2.imag;
return complex(c.real,c.imag);
}
void complex::display()
{   cout<<"("<<real<<","<<imag<<"i"<<")"<<endl; }

 

int main()     //主函數
{
complex c1(5,4),c2(2,10),c3; //聲明複數類的對象
cout<<"c1="; c1.display();
cout<<"c2="; c2.display();
c3=c1-c2; //使用重載運算子完成複數減法
cout<<"c3=c1-c2=";
c3.display();
c3=c1+c2; //使用重載運算子完成複數加法
cout<<"c3=c1+c2=";
c3.display();
system("pause");
return 0;
}

程式輸出的結果為：
c1=(5,4i)
c2=(2,10i)
c3=c1-c2=(3,-6i)
c3=c1+c2=(7,14i)

通過代碼我們可以看出： 定義了兩個成員函數重載運算子..重載了+ 和- . 當我們使用這個類的兩個成員進行相加的或者相減的時候就會自動調用重載的運算子..使用我們在重載的運算子中所定義的操作。那我們可以看到，在進行+或者-的時候是把兩個對象中儲存的複數的值進行加減 然後返回了。 要注意的是並不是+號和減號被完全改變了，而只是這個類中的對象在進行+ -操作的時候才會調用重載.

我們來測試一下; 我們在main()函數中再定義三個變數 ，int a=5,b=3,c;    c=a-b ; 然後再輸出c的值 ，我們發現輸出為2 . .這也證明了我們所定義的重載運算子並沒有改變它原來的功能..而是賦予了它多重的含義..

那我們再來看下運算子多載在友元函數中的使用。

我們只需要將complex complex::operator +(complex c2) //重載函數實現
                      {
                        complex c;
                        c.real=real+c2.real;    // real 代表 this->real 其實就是代表傳遞進來的當前對象.
                        c.imag=imag+c2.imag;
                        return complex(c.real,c.imag);
                      }

這段代碼 修改一下... 改為 complex friend complex::operator +(complex c2 complex c3)

那麼同樣也可以完成相同的功能..而且還更容易擴充..因為從上面得知..重載的運算子必須和使用者定義的自訂類型的對象一起使用. 也就是說至少有一個自訂類型..或者是它的引用..如果我們使用成員運算子多載的話只能使用類中的對象成員..而使用友元運算子多載那麼我們則可以使用類外的資料..當我們需要使用的時候直接修改為 complex friend complex::operator +(complex c2 int a) 如這樣的形式就可以了。