碼上歡樂
相關內容    簡體    繁體

C++運算符重載

本文轉載自   查看原文   2017-12-06 11:11   1218    C/C++

轉自：http://c.biancheng.net/cpp/biancheng/view/3011.html

 

一、C++運算符重載的概念和語法

所謂重載，就是賦予新的含義。函數重載（Function Overloading）可以讓一個函數名有多種功能，在不同情況下進行不同的操作。運算符重載（Operator Overloading）也是一個道理，同一個運算符可以有不同的功能。

實際上，我們已經在不知不覺中使用了運算符重載。例如，+號可以對不同類型（int、float 等）的數據進行加法操作；<<既是位移運算符，又可以配合 cout 向控制台輸出數據。C++ 本身已經對這些運算符進行了重載。

C++ 也允許程序員自己重載運算符，這給我們帶來了很大的便利。

下面的代碼定義了一個復數類，通過運算符重載，可以用+號實現復數的加法運算：

  1. #include <iostream>
  2. using namespace std;
  4. class complex{
  5. public:
  6. complex();
  7. complex(double real, double imag);
  8. public:
  9. //聲明運算符重載
  10. complex operator+(const complex &A) const;
  11. void display() const;
  12. private:
  13. double m_real; //實部
  14. double m_imag; //虛部
  15. };
  17. complex::complex(): m_real(0.0), m_imag(0.0){ }
  18. complex::complex(double real, double imag): m_real(real), m_imag(imag){ }
  20. //實現運算符重載
  21. complex complex::operator+(const complex &A) const{
  22. complex B;
  23. B.m_real = this->m_real + A.m_real;
  24. B.m_imag = this->m_imag + A.m_imag;
  25. return B;
  26. }
  28. void complex::display() const{
  29. cout<<m_real<<" + "<<m_imag<<"i"<<endl;
  30. }
  32. int main(){
  33. complex c1(4.3, 5.8);
  34. complex c2(2.4, 3.7);
  35. complex c3;
  36. c3 = c1 + c2;
  37. c3.display();
  39. return 0;
  40. }

運行結果：
6.7 + 9.5i

本例中義了一個復數類 complex，m_real 表示實部，m_imag 表示虛部，第 10 行聲明了運算符重載，第 21 行進行了實現（定義）。認真觀察這兩行代碼，可以發現運算符重載的形式與函數非常類似。

運算符重載其實就是定義一個函數，在函數體內實現想要的功能，當用到該運算符時，編譯器會自動調用這個函數。也就是說，運算符重載是通過函數實現的，它本質上是函數重載。

運算符重載的格式為：

返回值類型 operator 運算符名稱 (形參表列){
    //TODO:
}

operator是關鍵字，專門用於定義重載運算符的函數。我們可以將operator 運算符名稱這一部分看做函數名，對於上面的代碼，函數名就是operator+。

運算符重載函數除了函數名有特定的格式，其它地方和普通函數並沒有區別。

上面的例子中，我們在 complex 類中重載了運算符+，該重載只對 complex 對象有效。當執行c3 = c1 + c2;語句時，編譯器檢測到+號左邊（+號具有左結合性，所以先檢測左邊）是一個 complex 對象，就會調用成員函數operator+()，也就是轉換為下面的形式：

c3 = c1.operator+(c2);

c1 是要調用函數的對象，c2 是函數的實參。

上面的運算符重載還可以有更加簡練的定義形式：

  1. complex complex::operator+(const complex &A)const{
  2. return complex(this->m_real + A.m_real, this->m_imag + A.m_imag);
  3. }

return 語句中的complex(this->m_real + A.m_real, this->m_imag + A.m_imag)會創建一個臨時對象，這個對象沒有名稱，是一個匿名對象。在創建臨時對象過程中調用構造函數，return 語句將該臨時對象作為函數返回值。

在全局范圍內重載運算符

運算符重載函數不僅可以作為類的成員函數，還可以作為全局函數。更改上面的代碼，在全局范圍內重載+，實現復數的加法運算：

  1. #include <iostream>
  2. using namespace std;
  4. class complex{
  5. public:
  6. complex();
  7. complex(double real, double imag);
  8. public:
  9. void display() const;
  10. //聲明為友元函數
  11. friend complex operator+(const complex &A, const complex &B);
  12. private:
  13. double m_real;
  14. double m_imag;
  15. };
  17. complex operator+(const complex &A, const complex &B);
  19. complex::complex(): m_real(0.0), m_imag(0.0){ }
  20. complex::complex(double real, double imag): m_real(real), m_imag(imag){ }
  21. void complex::display() const{
  22. cout<<m_real<<" + "<<m_imag<<"i"<<endl;
  23. }
  25. //在全局范圍內重載+
  26. complex operator+(const complex &A, const complex &B){
  27. complex C;
  28. C.m_real = A.m_real + B.m_real;
  29. C.m_imag = A.m_imag + B.m_imag;
  30. return C;
  31. }
  33. int main(){
  34. complex c1(4.3, 5.8);
  35. complex c2(2.4, 3.7);
  36. complex c3;
  37. c3 = c1 + c2;
  38. c3.display();
  40. return 0;
  41. }

運算符重載函數不是 complex 類的成員函數，但是卻用到了 complex 類的 private 成員變量，所以必須在 complex 類中將該函數聲明為友元函數。

當執行c3 = c1 + c2;語句時，編譯器檢測到+號兩邊都是 complex 對象，就會轉換為類似下面的函數調用：

c3 = operator+(c1, c2);

小結

雖然運算符重載所實現的功能完全可以用函數替代，但運算符重載使得程序的書寫更加人性化，易於閱讀。運算符被重載后，原有的功能仍然保留，沒有喪失或改變。通過運算符重載，擴大了C++已有運算符的功能，使之能用於對象。

 

二、C++運算符重載的規則

運算符重載是通過函數重載實現的，概念上大家都很容易理解，這節我們來說一下運算符重載的注意事項。

1) 並不是所有的運算符都可以重載。能夠重載的運算符包括：
+  -  *  /  %  ^  &  |  ~  !  =  <  >  +=  -=  *=  /=  %=  ^=  &=  |=  <<  >>  <<=  >>=  ==  !=  <=  >=  &&  ||  ++  --  ,  ->*  ->  ()  []  new  new[]  delete  delete[]

上述運算符中，[]是下標運算符，()是函數調用運算符。自增自減運算符的前置和后置形式都可以重載。長度運算符sizeof、條件運算符: ?、成員選擇符.和域解析運算符::不能被重載。

2) 重載不能改變運算符的優先級和結合性。假設上一節的 complex 類中重載了+號和*號，並且 c1、c2、c3、c4 都是 complex 類的對象，那么下面的語句：

c4 = c1 + c2 * c3;

等價於：

c4 = c1 + ( c2 * c3 );

乘法的優先級仍然高於加法，並且它們仍然是二元運算符。

3) 重載不會改變運算符的用法，原有有幾個操作數、操作數在左邊還是在右邊，這些都不會改變。例如~號右邊只有一個操作數，+號總是出現在兩個操作數之間，重載后也必須如此。

4) 運算符重載函數不能有默認的參數，否則就改變了運算符操作數的個數，這顯然是錯誤的。

5) 運算符重載函數既可以作為類的成員函數，也可以作為全局函數。

將運算符重載函數作為類的成員函數時，二元運算符的參數只有一個，一元運算符不需要參數。之所以少一個參數，是因為這個參數是隱含的。

例如，上節的 complex 類中重載了加法運算符：

complex operator+(const complex & A) const;

當執行：

c3 = c1 + c2;

會被轉換為：

c3 = c1.operator+(c2);

通過 this 指針隱式的訪問 c1 的成員變量。

將運算符重載函數作為全局函數時，二元操作符就需要兩個參數，一元操作符需要一個參數，而且其中必須有一個參數是對象，好讓編譯器區分這是程序員自定義的運算符，防止程序員修改用於內置類型的運算符的性質。

例如，下面這樣是不對的：

  1. int operator + (int a,int b){
  2. return (a-b);
  3. }

+號原來是對兩個數相加，現在企圖通過重載使它的作用改為兩個數相減， 如果允許這樣重載的話，那么表達式4+3的結果是 7 還是 1 呢？顯然，這是絕對禁止的。

如果有兩個參數，這兩個參數可以都是對象，也可以一個是對象，一個是C ++內置類型的數據，例如：

  1. complex operator+(int a, complex &c){
  2. return complex(a+c.real, c.imag);
  3. }

它的作用是使一個整數和一個復數相加。

另外，將運算符重載函數作為全局函數時，一般都需要在類中將該函數聲明為友元函數。原因很簡單，該函數大部分情況下都需要使用類的 private 成員。

上節的最后一個例子中，我們在全局范圍內重載了+號，並在 complex 類中將運算符重載函數聲明為友元函數，因為該函數使用到了 complex 類的 m_real 和 m_imag 兩個成員變量，它們都是 private 屬性的，默認不能在類的外部訪問。

6) 箭頭運算符->、下標運算符[ ]、函數調用運算符( )、賦值運算符=只能以成員函數的形式重載。

 

三、C++重載數學運算符

四則運算符（+、-、*、/、+=、-=、*=、/=）和關系運算符（>、<、<=、>=、==、!=）都是數學運算符，它們在實際開發中非常常見，被重載的幾率也很高，並且有着相似的重載格式。本節以復數類 Complex 為例對它們進行重載，重在演示運算符重載的語法以及規范。

復數能夠進行完整的四則運算，但不能進行完整的關系運算：我們只能判斷兩個復數是否相等，但不能比較它們的大小，所以不能對 >、<、<=、>= 進行重載。下面是具體的代碼：

  1. #include <iostream>
  2. #include <cmath>
  3. using namespace std;
  5. //復數類
  6. class Complex{
  7. public: //構造函數
  8. Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
  9. public: //運算符重載
  10. //以全局函數的形式重載
  11. friend Complex operator+(const Complex &c1, const Complex &c2);
  12. friend Complex operator-(const Complex &c1, const Complex &c2);
  13. friend Complex operator*(const Complex &c1, const Complex &c2);
  14. friend Complex operator/(const Complex &c1, const Complex &c2);
  15. friend bool operator==(const Complex &c1, const Complex &c2);
  16. friend bool operator!=(const Complex &c1, const Complex &c2);
  17. //以成員函數的形式重載
  18. Complex & operator+=(const Complex &c);
  19. Complex & operator-=(const Complex &c);
  20. Complex & operator*=(const Complex &c);
  21. Complex & operator/=(const Complex &c);
  22. public: //成員函數
  23. double real() const{ return m_real; }
  24. double imag() const{ return m_imag; }
  25. private:
  26. double m_real; //實部
  27. double m_imag; //虛部
  28. };
  30. //重載+運算符
  31. Complex operator+(const Complex &c1, const Complex &c2){
  32. Complex c;
  33. c.m_real = c1.m_real + c2.m_real;
  34. c.m_imag = c1.m_imag + c2.m_imag;
  35. return c;
  36. }
  37. //重載-運算符
  38. Complex operator-(const Complex &c1, const Complex &c2){
  39. Complex c;
  40. c.m_real = c1.m_real - c2.m_real;
  41. c.m_imag = c1.m_imag - c2.m_imag;
  42. return c;
  43. }
  44. //重載*運算符 (a+bi) * (c+di) = (ac-bd) + (bc+ad)i
  45. Complex operator*(const Complex &c1, const Complex &c2){
  46. Complex c;
  47. c.m_real = c1.m_real * c2.m_real - c1.m_imag * c2.m_imag;
  48. c.m_imag = c1.m_imag * c2.m_real + c1.m_real * c2.m_imag;
  49. return c;
  50. }
  51. //重載/運算符 (a+bi) / (c+di) = [(ac+bd) / (c²+d²)] + [(bc-ad) / (c²+d²)]i
  52. Complex operator/(const Complex &c1, const Complex &c2){
  53. Complex c;
  54. c.m_real = (c1.m_real*c2.m_real + c1.m_imag*c2.m_imag) / (pow(c2.m_real, 2) + pow(c2.m_imag, 2));
  55. c.m_imag = (c1.m_imag*c2.m_real - c1.m_real*c2.m_imag) / (pow(c2.m_real, 2) + pow(c2.m_imag, 2));
  56. return c;
  57. }
  58. //重載==運算符
  59. bool operator==(const Complex &c1, const Complex &c2){
  60. if( c1.m_real == c2.m_real && c1.m_imag == c2.m_imag ){
  61. return true;
  62. }else{
  63. return false;
  64. }
  65. }
  66. //重載!=運算符
  67. bool operator!=(const Complex &c1, const Complex &c2){
  68. if( c1.m_real != c2.m_real || c1.m_imag != c2.m_imag ){
  69. return true;
  70. }else{
  71. return false;
  72. }
  73. }
  75. //重載+=運算符
  76. Complex & Complex::operator+=(const Complex &c){
  77. this->m_real += c.m_real;
  78. this->m_imag += c.m_imag;
  79. return *this;
  80. }
  81. //重載-=運算符
  82. Complex & Complex::operator-=(const Complex &c){
  83. this->m_real -= c.m_real;
  84. this->m_imag -= c.m_imag;
  85. return *this;
  86. }
  87. //重載*=運算符
  88. Complex & Complex::operator*=(const Complex &c){
  89. this->m_real = this->m_real * c.m_real - this->m_imag * c.m_imag;
  90. this->m_imag = this->m_imag * c.m_real + this->m_real * c.m_imag;
  91. return *this;
  92. }
  93. //重載/=運算符
  94. Complex & Complex::operator/=(const Complex &c){
  95. this->m_real = (this->m_real*c.m_real + this->m_imag*c.m_imag) / (pow(c.m_real, 2) + pow(c.m_imag, 2));
  96. this->m_imag = (this->m_imag*c.m_real - this->m_real*c.m_imag) / (pow(c.m_real, 2) + pow(c.m_imag, 2));
  97. return *this;
  98. }
  100. int main(){
  101. Complex c1(25, 35);
  102. Complex c2(10, 20);
  103. Complex c3(1, 2);
  104. Complex c4(4, 9);
  105. Complex c5(34, 6);
  106. Complex c6(80, 90);
  108. Complex c7 = c1 + c2;
  109. Complex c8 = c1 - c2;
  110. Complex c9 = c1 * c2;
  111. Complex c10 = c1 / c2;
  112. cout<<"c7 = "<<c7.real()<<" + "<<c7.imag()<<"i"<<endl;
  113. cout<<"c8 = "<<c8.real()<<" + "<<c8.imag()<<"i"<<endl;
  114. cout<<"c9 = "<<c9.real()<<" + "<<c9.imag()<<"i"<<endl;
  115. cout<<"c10 = "<<c10.real()<<" + "<<c10.imag()<<"i"<<endl;
  117. c3 += c1;
  118. c4 -= c2;
  119. c5 *= c2;
  120. c6 /= c2;
  121. cout<<"c3 = "<<c3.real()<<" + "<<c3.imag()<<"i"<<endl;
  122. cout<<"c4 = "<<c4.real()<<" + "<<c4.imag()<<"i"<<endl;
  123. cout<<"c5 = "<<c5.real()<<" + "<<c5.imag()<<"i"<<endl;
  124. cout<<"c6 = "<<c6.real()<<" + "<<c6.imag()<<"i"<<endl;
  126. if(c1 == c2){
  127. cout<<"c1 == c2"<<endl;
  128. }
  129. if(c1 != c2){
  130. cout<<"c1 != c2"<<endl;
  131. }
  133. return 0;
  134. }

運行結果：
c7 = 35 + 55i
c8 = 15 + 15i
c9 = -450 + 850i
c10 = 1.9 + -0.3i
c3 = 26 + 37i
c4 = -6 + -11i
c5 = 220 + 4460i
c6 = 5.2 + 1.592i
c1 != c2

需要注意的是，我們以全局函數的形式重載了 +、-、*、/、==、!=，以成員函數的形式重載了 +=、-=、*=、/=，而且應該堅持這樣做，不能一股腦都寫作成員函數或者全局函數，具體原因我們將在下節講解。

 

四、C++重載>>和<<（輸入輸出運算符）

在C++中，標准庫本身已經對左移運算符<<和右移運算符>>分別進行了重載，使其能夠用於不同數據的輸入輸出，但是輸入輸出的對象只能是 C++ 內置的數據類型（例如 bool、int、double 等）和標准庫所包含的類類型（例如 string、complex、ofstream、ifstream 等）。

如果我們自己定義了一種新的數據類型，需要用輸入輸出運算符去處理，那么就必須對它們進行重載。本節以前面的 complex 類為例來演示輸入輸出運算符的重載。

其實 C++ 標准庫已經提供了 complex 類，能夠很好地支持復數運算，但是這里我們又自己定義了一個 complex 類，這樣做僅僅是為了教學演示。

本節要達到的目標是讓復數的輸入輸出和 int、float 等基本類型一樣簡單。假設 num1、num2 是復數，那么輸出形式就是：

cout<<num1<<num2<<endl;

輸入形式就是：

cin>>num1>>num2;

cout 是 istream 類的對象，cin 是 ostream 類的對象，要想達到這個目標，就必須以全局函數（友元函數）的形式重載<<和>>，否則就要修改標准庫中的類，這顯然不是我們所期望的。

重載輸入運算符>>

下面我們以全局函數的形式重載>>，使它能夠讀入兩個 double 類型的數據，並分別賦值給復數的實部和虛部：

  1. istream & operator>>(istream &in, complex &A){
  2. in >> A.m_real >> A.m_imag;
  3. return in;
  4. }

istream 表示輸入流，cin 是 istream 類的對象，只不過這個對象是在標准庫中定義的。之所以返回 istream 類對象的引用，是為了能夠連續讀取復數，讓代碼書寫更加漂亮，例如：

complex c1, c2;
cin>>c1>>c2;

如果不返回引用，那就只能一個一個地讀取了：

complex c1, c2;
cin>>c1;
cin>>c2;

另外，運算符重載函數中用到了 complex 類的 private 成員變量，必須在 complex 類中將該函數聲明為友元函數：

friend istream & operator>>(istream & in , complex &a);

>>運算符可以按照下面的方式使用：

complex c;
cin>>c;

當輸入1.45 2.34↙后，這兩個小數就分別成為對象 c 的實部和虛部了。cin>> c;這一語句其實可以理解為：

operator<<(cin , c);

重載輸出運算符<<

同樣地，我們也可以模仿上面的形式對輸出運算符>>進行重載，讓它能夠輸出復數，請看下面的代碼：

  1. ostream & operator<<(ostream &out, complex &A){
  2. out << A.m_real <<" + "<< A.m_imag <<" i ";
  3. return out;
  4. }

ostream 表示輸出流，cout 是 ostream 類的對象。由於采用了引用的方式進行參數傳遞，並且也返回了對象的引用，所以重載后的運算符可以實現連續輸出。

為了能夠直接訪問 complex 類的 private 成員變量，同樣需要將該函數聲明為 complex 類的友元函數：

friend ostream & operator<<(ostream &out, complex &A);

綜合演示

結合輸入輸出運算符的重載，重新實現 complex 類：

  1. #include <iostream>
  2. using namespace std;
  4. class complex{
  5. public:
  6. complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ };
  7. public:
  8. friend complex operator+(const complex & A, const complex & B);
  9. friend complex operator-(const complex & A, const complex & B);
  10. friend complex operator*(const complex & A, const complex & B);
  11. friend complex operator/(const complex & A, const complex & B);
  12. friend istream & operator>>(istream & in, complex & A);
  13. friend ostream & operator<<(ostream & out, complex & A);
  14. private:
  15. double m_real; //實部
  16. double m_imag; //虛部
  17. };
  19. //重載加法運算符
  20. complex operator+(const complex & A, const complex &B){
  21. complex C;
  22. C.m_real = A.m_real + B.m_real;
  23. C.m_imag = A.m_imag + B.m_imag;
  24. return C;
  25. }
  27. //重載減法運算符
  28. complex operator-(const complex & A, const complex &B){
  29. complex C;
  30. C.m_real = A.m_real - B.m_real;
  31. C.m_imag = A.m_imag - B.m_imag;
  32. return C;
  33. }
  35. //重載乘法運算符
  36. complex operator*(const complex & A, const complex &B){
  37. complex C;
  38. C.m_real = A.m_real * B.m_real - A.m_imag * B.m_imag;
  39. C.m_imag = A.m_imag * B.m_real + A.m_real * B.m_imag;
  40. return C;
  41. }
  43. //重載除法運算符
  44. complex operator/(const complex & A, const complex & B){
  45. complex C;
  46. double square = A.m_real * A.m_real + A.m_imag * A.m_imag;
  47. C.m_real = (A.m_real * B.m_real + A.m_imag * B.m_imag)/square;
  48. C.m_imag = (A.m_imag * B.m_real - A.m_real * B.m_imag)/square;
  49. return C;
  50. }
  52. //重載輸入運算符
  53. istream & operator>>(istream & in, complex & A){
  54. in >> A.m_real >> A.m_imag;
  55. return in;
  56. }
  58. //重載輸出運算符
  59. ostream & operator<<(ostream & out, complex & A){
  60. out << A.m_real <<" + "<< A.m_imag <<" i ";;
  61. return out;
  62. }
  64. int main(){
  65. complex c1, c2, c3;
  66. cin>>c1>>c2;
  68. c3 = c1 + c2;
  69. cout<<"c1 + c2 = "<<c3<<endl;
  71. c3 = c1 - c2;
  72. cout<<"c1 - c2 = "<<c3<<endl;
  74. c3 = c1 * c2;
  75. cout<<"c1 * c2 = "<<c3<<endl;
  77. c3 = c1 / c2;
  78. cout<<"c1 / c2 = "<<c3<<endl;
  80. return 0;
  81. }

運行結果：
2.4 3.6↙
4.8 1.7↙
c1 + c2 = 7.2 + 5.3 i
c1 - c2 = -2.4 + 1.9 i
c1 * c2 = 5.4 + 21.36 i
c1 / c2 = 0.942308 + 0.705128 i

 

五、C++重載[ ]（下標運算符）

C++ 規定，下標運算符[ ]必須以成員函數的形式進行重載。該重載函數在類中的聲明格式如下：

返回值類型 & operator[ ] (參數);

或者：

const 返回值類型 & operator[ ] (參數) const;

使用第一種聲明方式，[ ]不僅可以訪問元素，還可以修改元素。使用第二種聲明方式，[ ]只能訪問而不能修改元素。在實際開發中，我們應該同時提供以上兩種形式，這樣做是為了適應 const 對象，因為通過 const 對象只能調用 const 成員函數，如果不提供第二種形式，那么將無法訪問 const 對象的任何元素。

下面我們通過一個具體的例子來演示如何重載[ ]。我們知道，有些較老的編譯器不支持變長數組，例如 VC6.0、VS2010 等，這有時候會給編程帶來不便，下面我們通過自定義的 Array 類來實現變長數組。

  1. #include <iostream>
  2. using namespace std;
  4. class Array{
  5. public:
  6. Array(int length = 0);
  7. ~Array();
  8. public:
  9. int & operator[](int i);
  10. const int & operator[](int i) const;
  11. public:
  12. int length() const { return m_length; }
  13. void display() const;
  14. private:
  15. int m_length; //數組長度
  16. int *m_p; //指向數組內存的指針
  17. };
  19. Array::Array(int length): m_length(length){
  20. if(length == 0){
  21. m_p = NULL;
  22. }else{
  23. m_p = new int[length];
  24. }
  25. }
  27. Array::~Array(){
  28. delete[] m_p;
  29. }
  31. int& Array::operator[](int i){
  32. return m_p[i];
  33. }
  35. const int & Array::operator[](int i) const{
  36. return m_p[i];
  37. }
  39. void Array::display() const{
  40. for(int i = 0; i < m_length; i++){
  41. if(i == m_length - 1){
  42. cout<<m_p[i]<<endl;
  43. }else{
  44. cout<<m_p[i]<<", ";
  45. }
  46. }
  47. }
  49. int main(){
  50. int n;
  51. cin>>n;
  53. Array A(n);
  54. for(int i = 0, len = A.length(); i < len; i++){
  55. A[i] = i * 5;
  56. }
  57. A.display();
  59. const Array B(n);
  60. cout<<B[n-1]<<endl; //訪問最后一個元素
  62. return 0;
  63. }

運行結果：
5↙
0, 5, 10, 15, 20
33685536

重載[ ]運算符以后，表達式arr[i]會被轉換為：

arr.operator[ ](i);

需要說明的是，B 是 const 對象，如果 Array 類沒有提供 const 版本的operator[ ]，那么第 60 行代碼將報錯。雖然第 60 行代碼只是讀取對象的數據，並沒有試圖修改對象，但是它調用了非 const 版本的operator[ ]，編譯器不管實際上有沒有修改對象，只要是調用了非 const 的成員函數，編譯器就認為會修改對象（至少有這種風險）。

 

六、C++重載++和--（自增自減運算符）

自增++和自減--都是一元運算符，它的前置形式和后置形式都可以被重載。請看下面的例子：

  1. #include <iostream>
  2. #include <iomanip>
  3. using namespace std;
  5. //秒表類
  6. class stopwatch{
  7. public:
  8. stopwatch(): m_min(0), m_sec(0){ }
  9. public:
  10. void setzero(){ m_min = 0; m_sec = 0; }
  11. stopwatch run(); // 運行
  12. stopwatch operator++(); //++i，前置形式
  13. stopwatch operator++(int); //i++，后置形式
  14. friend ostream & operator<<( ostream &, const stopwatch &);
  15. private:
  16. int m_min; //分鍾
  17. int m_sec; //秒鍾
  18. };
  20. stopwatch stopwatch::run(){
  21. ++m_sec;
  22. if(m_sec == 60){
  23. m_min++;
  24. m_sec = 0;
  25. }
  26. return *this;
  27. }
  29. stopwatch stopwatch::operator++(){
  30. return run();
  31. }
  33. stopwatch stopwatch::operator++(int n){
  34. stopwatch s = *this;
  35. run();
  36. return s;
  37. }
  39. ostream &operator<<( ostream & out, const stopwatch & s){
  40. out<<setfill('0')<<setw(2)<<s.m_min<<":"<<setw(2)<<s.m_sec;
  41. return out;
  42. }
  44. int main(){
  45. stopwatch s1, s2;
  47. s1 = s2++;
  48. cout << "s1: "<< s1 <<endl;
  49. cout << "s2: "<< s2 <<endl;
  50. s1.setzero();
  51. s2.setzero();
  53. s1 = ++s2;
  54. cout << "s1: "<< s1 <<endl;
  55. cout << "s2: "<< s2 <<endl;
  56. return 0;
  57. }

運行結果：
s1: 00:00
s2: 00:01
s1: 00:01
s2: 00:01

上面的代碼定義了一個簡單的秒表類，m_min 表示分鍾，m_sec 表示秒鍾，setzero() 函數用於秒表清零，run() 函數是用來描述秒針前進一秒的動作，接下來是三個運算符重載函數。

先來看一下 run() 函數的實現，run() 函數一開始讓秒針自增，如果此時自增結果等於60了，則應該進位，分鍾加1，秒針置零。

operator++() 函數實現自增的前置形式，直接返回 run() 函數運行結果即可。

operator++ (int n) 函數實現自增的后置形式，返回值是對象本身，但是之后再次使用該對象時，對象自增了，所以在該函數的函數體中，先將對象保存，然后調用一次 run() 函數，之后再將先前保存的對象返回。在這個函數中參數n是沒有任何意義的，它的存在只是為了區分是前置形式還是后置形式。

自減運算符的重載與上面類似，這里不再贅述。

 

七、C++重載new和delete運算符

內存管理運算符 new、new[]、delete 和 delete[] 也可以進行重載，其重載形式既可以是類的成員函數，也可以是全局函數。一般情況下，內建的內存管理運算符就夠用了，只有在需要自己管理內存時才會重載。

以成員函數的形式重載 new 運算符：

void * className::operator new( size_t size ){
    //TODO:
}

以全局函數的形式重載 new 運算符：

void * operator new( size_t size ){
    //TODO:
}

兩種重載形式的返回值相同，都是void *類型，並且都有一個參數，為size_t類型。在重載 new 或 new[] 時，無論是作為成員函數還是作為全局函數，它的第一個參數必須是 size_t 類型。size_t 表示的是要分配空間的大小，對於 new[] 的重載函數而言，size_t 則表示所需要分配的所有空間的總和。

size_t 在頭文件 <cstdio> 中被定義為 typedef unsigned int size_t;，也就是無符號整型。

當然，重載函數也可以有其他參數，但都必須有默認值，並且第一個參數的類型必須是 size_t。

同樣的，delete 運算符也有兩種重載形式。以類的成員函數的形式進行重載：

void className::operator delete( void *ptr){
    //TODO:
}

以全局函數的形式進行重載：

void operator delete( void *ptr){
    //TODO:
}

兩種重載形式的返回值都是 void 類型，並且都必須有一個 void 類型的指針作為參數，該指針指向需要釋放的內存空間。

當我們以類的成員函數的形式重載了new 和 delete 操作符，其使用方法如下：

純文本復制
  1. C * c = new C; //分配內存空間
  2. //TODO:
  3. delete c; //釋放內存空間

如果類中沒有定義 new 和 delete 的重載函數，那么會自動調用內建的 new 和 delete 運算符。

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 C++運算符重載 C++左移運算符重載 c++運算符重載 c++運算符重載之加號(+) C++ 運算符重載_加號 C++ 運算符重載--operator c++ 運算符重載 C++ 運算符重載 C++:運算符重載函數 C++多態-------運算符的重載
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM