運算符重載為成員函數

轉自：https://www.runoob.com/cplusplus/increment-decrement-operators-overloading.html

重載為類成員的運算符函數定義形式

1.  
   函數類型 operator 運算符（形參）
2.  
   {
3.  
   ......
4.  
   }
5.  
   參數個數=原操作數個數-1 （后置++、--除外）
6.  
    

雙目運算符重載規則

• 如果要重載 B 為類成員函數，使之能夠實現表達式 oprd1 B oprd2，其中 oprd1 為A 類對象，則 B 應被重載為 A 類的成員函數，形參類型應該是 oprd2 所屬的類型。
• 經重載后，表達式 oprd1 B oprd2 相當於 oprd1.operator B(oprd2)

例：復數類加減法運算重載為成員函數

• 要求:
  • 將+、-運算重載為復數類的成員函數。
• 規則:
  • 實部和虛部分別相加減。
• 操作數:
  • 兩個操作數都是復數類的對象。

• 源代碼：

1.  
   #include <iostream>
2.  
   using namespace std;
3.  
   class Complex {
4.  
   public:
5.  
   Complex( double r = 0.0, double i = 0.0) : real(r), imag(i) { }
6.  
   //運算符+重載成員函數
7.  
   Complex operator + (const Complex &c2) const;
8.  
   //運算符-重載成員函數
9.  
   Complex operator - (const Complex &c2) const;
10.  
    void display() const; //輸出復數
11.  
    private:
12.  
    double real; //復數實部
13.  
    double imag; //復數虛部
14.  
    };
15.  
    例 復數類加減法運算重載為成員函數
16.  
    Complex Complex:: operator+(const Complex &c2) const{
17.  
    //創建一個臨時無名對象作為返回值
18.  
    return Complex(real+c2.real, imag+c2.imag);
19.  
    }
20.  
     
21.  
    Complex Complex:: operator-(const Complex &c2) const{
22.  
    //創建一個臨時無名對象作為返回值
23.  
    return Complex(real-c2.real, imag-c2.imag);
24.  
    }
25.  
     
26.  
    void Complex::display() const {
27.  
    cout<<"("<<real<<", "<<imag<<")"<<endl;
28.  
    }
29.  
    例：復數類加減法運算重載為成員函數
30.  
    int main() {
31.  
    Complex c1(5, 4), c2(2, 10), c3;
32.  
    cout << "c1 = "; c1.display();
33.  
    cout << "c2 = "; c2.display();
34.  
    c3 = c1 - c2; //使用重載運算符完成復數減法
35.  
    cout << "c3 = c1 - c2 = "; c3.display();
36.  
    c3 = c1 + c2; //使用重載運算符完成復數加法
37.  
    cout << "c3 = c1 + c2 = "; c3.display();
38.  
    return 0;
39.  
    }

運算符重載為非成員函數

有些運算符不能重載為成員函數，例如二元運算符的左操作數不是對象，或者是不能由我們重載運算符的對象

運算符重載為非成員函數的規則

• 函數的形參代表依自左至右次序排列的各操作數。
• 重載為非成員函數時
• 參數個數=原操作數個數（后置++、--除外）
• 至少應該有一個自定義類型的參數。
• 后置單目運算符 ++和--的重載函數，形參列表中要增加一個int，但不必寫形參名。
• 如果在運算符的重載函數中需要操作某類對象的私有成員，可以將此函數聲明為該類的友元。

運算符重載為非成員函數的規則

• 雙目運算符 B重載后，

表達式oprd1 B oprd2

等同於operator B(oprd1,oprd2 )

• 前置單目運算符 B重載后，

表達式 B oprd

等同於operator B(oprd )

• 后置單目運算符 ++和--重載后，

表達式 oprd B

等同於operator B(oprd,0 )

例 重載Complex的加減法和“<<”運算符為非成員函數

• 將+、-（雙目）重載為非成員函數，並將其聲明為復數類的友元，兩個操作數都是復數類的常引用。 • 將<<（雙目）重載為非成員函數，並將其聲明為復數類的友元，它的左操作數是std::ostream引用，右操作數為復數類的常引用，返回std::ostream引用，用以支持下面形式的輸出：

cout << a << b;

 

該輸出調用的是：

operator << (operator << (cout, a), b);

源代碼：

1.  
   #include <iostream>
2.  
   using namespace std;
3.  
    
4.  
   class Complex {
5.  
   public:
6.  
   Complex( double r = 0.0, double i = 0.0) : real(r), imag(i) { }
7.  
   friend Complex operator+(const Complex &c1, const Complex &c2);
8.  
   friend Complex operator-(const Complex &c1, const Complex &c2);
9.  
   friend ostream & operator<<(ostream &out, const Complex &c);
10.  
    private:
11.  
    double real; //復數實部
12.  
    double imag; //復數虛部
13.  
    };
14.  
     
15.  
    Complex operator+(const Complex &c1, const Complex &c2){
16.  
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
17.  
    }
18.  
    Complex operator-(const Complex &c1, const Complex &c2){
19.  
    return Complex(c1.real - c2.real, c1.imag - c2.imag);
20.  
    }
21.  
     
22.  
    ostream & operator<<(ostream &out, const Complex &c){
23.  
    out << "(" << c.real << ", " << c.imag << ")";
24.  
    return out;
25.  
    }
26.  
     
27.  
    int main() {
28.  
    Complex c1(5, 4), c2(2, 10), c3;
29.  
    cout << "c1 = " << c1 << endl;
30.  
    cout << "c2 = " << c2 << endl;
31.  
    c3 = c1 - c2; //使用重載運算符完成復數減法
32.  
    cout << "c3 = c1 - c2 = " << c3 << endl;
33.  
    c3 = c1 + c2; //使用重載運算符完成復數加法
34.  
    cout << "c3 = c1 + c2 = " << c3 << endl;
35.  
    return 0;
36.  
    }

 

前置單目運算符重載規則

• 如果要重載 U 為類成員函數，使之能夠實現表達式 U oprd，其中 oprd 為A類對象，則 U 應被重載為 A 類的成員函數，無形參。
• 經重載后，表達式 U oprd 相當於 oprd.operator U()

后置單目運算符 ++和--重載規則

• 如果要重載 ++或--為類成員函數，使之能夠實現表達式 oprd++ 或 oprd-- ，其中 oprd 為A類對象，則 ++或-- 應被重載為 A 類的成員函數，且具有一個 int 類型形參。
• 經重載后，表達式 oprd++ 相當於 oprd.operator ++(0)

重載前置++和后置++為時鍾類成員函數

• 前置單目運算符，重載函數沒有形參
• 后置++運算符，重載函數需要有一個int形參
• 操作數是時鍾類的對象。

• 實現時間增加1秒鍾。

1.  
   #include <iostream>
2.  
   using namespace std;
3.  
   class Clock {//時鍾類定義
4.  
   public:
5.  
   Clock( int hour = 0, int minute = 0, int second = 0);
6.  
   void showTime() const;
7.  
   //前置單目運算符重載
8.  
   Clock& operator ++ ();
9.  
   //后置單目運算符重載
10.  
    Clock operator ++ (int);
11.  
    private:
12.  
    int hour, minute, second;
13.  
    };
14.  
     
15.  
    Clock::Clock( int hour, int minute, int second) {
16.  
    if (0 <= hour && hour < 24 && 0 <= minute && minute < 60
17.  
    && 0 <= second && second < 60) {
18.  
    this->hour = hour;
19.  
    this->minute = minute;
20.  
    this->second = second;
21.  
    } else
22.  
    cout << "Time error!" << endl;
23.  
    }
24.  
    void Clock::showTime() const { //顯示時間
25.  
    cout << hour << ":" << minute << ":" << second << endl;
26.  
    }
27.  
     
28.  
    //依次重載前置++和后置++為時鍾類成員函數定義
29.  
    Clock & Clock:: operator ++ () {
30.  
    second++;
31.  
    if (second >= 60) {
32.  
    second -= 60; minute++;
33.  
    if (minute >= 60) {
34.  
    minute -= 60; hour = (hour + 1) % 24;
35.  
    }
36.  
    }
37.  
    return *this;
38.  
    }
39.  
     
40.  
    Clock Clock:: operator ++ (int) {
41.  
    //注意形參表中的整型參數
42.  
    Clock old = * this;
43.  
    ++(* this); //調用前置“++”運算符
44.  
    return old;
45.  
    }
46.  
    int main() {
47.  
    Clock myClock(23, 59, 59);
48.  
    cout << "First time output: ";
49.  
    myClock.showTime();
50.  
    cout << "Show myClock++: ";
51.  
    (myClock++).showTime();
52.  
    cout << "Show ++myClock: ";
53.  
    (++myClock).showTime();
54.  
    return 0;
55.  
    }

Clock Clock::operator ++ (int)這個函數表示后置++，函數內部定義了一個局部變量old，在其生存期結束時會被釋放掉，故不能使用返回引用的定義，否則會指向被釋放掉的內存空間中的不確定的值。無論重復使用多少次后置++運算，也只會改變一次原有myclock對象的值（例如myclock++++++因為只有第一次++時*this表示myclock對象，后面都是old對象，就算使用引用也是一樣的，更何況沒使用引用無法連續賦值）。

Clock &Clock::operator ++ (int)這個函數表示前置++，返回的是當前對象的引用，故多次調用前置++運算符時，會一直對對象myclock進行賦值。如果取消引用符號，(++++++myclock).show還是會顯示三次自增后的結果，究其原因是保存的一個臨時變量副本，但myclock依然是只有一次自增的結果，這種情況充分說明了引用&能使返回對象為左值。

上述程序運行結果

改動下main函數：

1.  
   int main() {
2.  
   Clock myClock(23, 59, 59);
3.  
   cout << "First time output: ";
4.  
   myClock.showTime();
5.  
   cout << "Show myClock++: ";
6.  
   (myClock++++++).showTime();
7.  
   myClock.showTime();
8.  
   cout << "Show ++myClock: ";
9.  
   (++++++myClock).showTime();
10.  
    myClock.showTime();
11.  
     
12.  
    system( "pause");
13.  
    return 0;
14.  
    }

結果如下：

*this表示當前對象，Clock & Clock::operator ++ ()中的引用表示返回的是一個本類對象的引用，即返回的是一個左值。

為了更好地理解左值的概念，我們下面舉一個簡單的例子：

1.  
   #include<iostream>
2.  
   using namespace std;
3.  
    
4.  
   class Test{
5.  
    
6.  
   public:
7.  
   //構造函數
8.  
   Test( int i = 0, double j = 0.0) : m_i(i), m_j(j){
9.  
    
10.  
    }
11.  
     
12.  
    //賦值構造函數
13.  
    Test operator=(Test &rhs){ //返回引用
14.  
    this->m_i = rhs.m_i;
15.  
    this->m_j = rhs.m_j;
16.  
    return *this;
17.  
    }
18.  
    //Test operator=(Test &rhs){ //返回值
19.  
    //this->m_i = rhs.m_i;
20.  
    //this->m_j = rhs.m_j;
21.  
    //return *this;}
22.  
     
23.  
    int m_i;
24.  
    double m_j;
25.  
    };
26.  
     
27.  
     
28.  
    int main(){
29.  
     
30.  
    //1、賦初值，輸出 1 2.3
31.  
    Test obj1(1, 2.3);
32.  
    cout << obj1.m_i << endl << obj1.m_j << endl;
33.  
    cout << endl << "-------------------" << endl;
34.  
     
35.  
    //2、未賦初值，輸出0 0
36.  
    Test obj2;
37.  
    cout << obj2.m_i << endl << obj2.m_j << endl;
38.  
    cout << endl << "-------------------" << endl;
39.  
     
40.  
    //3、未賦初值，但是通過賦值構造函數進行了賦初值，但是注意是重復調用賦值構造函數賦初值。
41.  
    Test obj3;
42.  
    (obj3 = obj2 )= obj1; //這里，先進行obj3 = obj2 的操作, (賦值成功后通過return *this，返回obj2對象), 然后進行 obj3 = obj1 的操作。
43.  
    cout << obj3.m_i << endl << obj3.m_j << endl;
44.  
    cout << endl << "-------------------" << endl;
45.  
     
46.  
    system( "pause");
47.  
    return 0;
48.  
    }

 

函數返回引用的運行結果如下：

函數返回值的運行結果如下：

 

從運行結果可以看出當返回值時，函數返回值時會產生一個臨時變量作為函數返回值的副本，並調用復制構造函數將*this傳給這個臨時變量，並且賦值得到的是一個右值，右值是不能繼續賦值的，而返回引用時，引用就是obj對象本身，賦值得到一個左值，是可以繼續賦值的，其原因是這是為了支持連續的=號操作，如：A a,b,c  .調用(a=b)=c,這種情況下就要要求重載操作符=號必須返回一個*this的引用，這樣a=b才能得到一個更新后的a,再用c對其賦值才能作用到更新 的a身上，如果不返回*this的引用，將無法完成第二次用c的那個賦值。調用成員函數時*this指向該對象本身。

下面分類講述返回“值”和返回“引用”的不同點：

函數返回值時會產生一個臨時變量作為函數返回值的副本，而返回引用時不會產生值的副本。

T f(); 返回一般的類類型，返回的類類型不能作為左值，但返回的類類型可以直接調用成員函數來修改，如function().set_Value(); 返回類類型調用復制構造函數。
const T f(); 此種類型與上述第一種相同，唯一不同的是返回的類類型不能調用成員函數來修改，因為有const限定符。
T& f(); 返回類的引用可以作為左值，並且返回的類類型引用可以直接調用成員函數來修改，返回的類類型不會調用復制構造函數。
const T& f(); 不能作為左值，不能調用成員函數修改，不會調用復制構造函數。