C++ 面向對象的三個特色--多態性（二）

• 運算符重載

運算符重載，就是對已有的運算符從新進行定義，賦予其另外一種功能，以適應不一樣的數據類型。

1. 類外部的運算符重載

首先，咱們經過一個例子來講明爲何要有運算符重載。

 1 // Complex.h
 2 class Complex
 3 {
 4 public:
 5     int a;
 6     int b;
 7     Complex(int i = 0, int j = 0)
 8     {   a = i;b = j; }
 9 };
10 // main
11 #include "stdafx.h"
12 #include "stdlib.h"
13 #include "Complex.h"
14 // 類外部定義的運算符重載
15 Complex operator+(Complex c1, Complex c2)
16 {
17     Complex temp;
18     temp.a = c1.a + c2.a;
19     temp.b = c1.b + c2.b;
20     return temp;
21 }
22 
23 int _tmain(int argc, _TCHAR* argv[])
24 {
25     Complex com1(1, 3), com2(2,4);
26     Complex total;
27     total = com1 + com2;
28     printf("total.a = %d, total.b = %d\n", total.a, total.b);
29 
30     system("pause");
31     return 0;
32 }

說明：

C++知道如何把兩個int型數據相加，可是他們不能把兩個類Complex直接相加，運算符重載就是爲了解決這種相似的問題，也極大的豐富了運算符的特性。

C++語言對運算符重載的規則：

（1）.運算符重載是針對新類型數據的須要，對原有運算符進行適當的改造完成的。通常來說，重載的功能應當與原來的功能相似。

（2）.C++語言中只能重載原先已經定義了的運算符，程序員不能本身臆造新的運算符來擴充C++語言。

（3）.如下的幾個運算符是不能重載的：類屬關係運算符「.」、成員指針運算符「*」、做用域分辨符「::」、sizeof運算符和三目運算符「?:」。

（4）.不能改變運算符的操做個數。

（5）.不能改變運算符的原有優先級。

（6）.不能改變運算符的原有結合特性。

2. 友元運算符函數

咱們上面看到的運算符重載是在類的外部定義的，它只能訪問類中的公有成員數據。實際上，運算符重載函數通常採用如下兩種形式：一是成員運算符函數重載，而是友元運算符函數重載。

友元運算符函數的定義規則是：

類的內部聲明格式

Class X{

// ···

Friend 返回類型 operator 運算符（形參表）

// ···};

類的外部定義格式

返回類型 operator 運算符（形參表）

{

    函數體

}

友元函數不是該類的成員函數，因此在類外部定義是不須要寫上這個類的類名，因爲友元函數沒有this指針，因此若是友元運算符函數重載的是雙目運算符，則參數表中有兩個操做數，若是是單目運算符，則是一個操做數。

 1 // Complex.h
 2 class Complex
 3 {
 4 public:
 5     Complex(int i = 0, int j = 0)
 6     {
 7        a = i;
 8        b = j;
 9     }
10 
11     friend Complex operator+(Complex c1, Complex c2);
12 public:
13     int a;
14     int b;
15 };
16 // Complex.cpp
17 #include "StdAfx.h"
18 #include "Complex.h"
19 Complex operator+(Complex c1, Complex c2)
20 {
21     Complex temp;
22     temp.a = c1.a + c2.a;
23     temp.b = c1.b + c2.b;
24     return temp;
25 }
26 // main
27 int _tmain(int argc, _TCHAR* argv[])
28 {
29     Complex com1(1, 3), com2(2,4);
30     Complex total;
31     total = com1 + com2;
32     printf("total.a = %d, total.b = %d\n", total.a, total.b);
33     system("pause");
34     return 0;
35 }

有一個須要注意的地方，就是友元函數重載「++」、「--」這樣的運算符，可能會出現問題。

說明：

（1）. 運算符重載能夠返回任何類型，但一般與他所操做的類的類型相同。

（2）. 重載運算符時，最好保持運算符的原含義，以防混淆。

（3）. C++中，用戶不能定義新的運算符，只能從已有的運算符中選擇一個恰當的運算符進行重載。

（4）. 不能用友元函數重載如下運算符：=，()，[]，->

3.成員運算符重載

把運算符函數定義爲某個類的成員函數，稱爲成員運算符重載。

 1 // Complex.h
 2 class Complex
 3 {
 4 public:
 5     Complex(int i = 0, int j = 0)
 6     {
 7        a = i;
 8        b = j;
 9     }
10     Complex operator+(Complex c);
11 
12 public:
13     int a;
14     int b;
15 };
16 // Complex.cpp
17 #include "StdAfx.h"
18 #include "Complex.h"
19 
20 Complex Complex::operator+(Complex c)
21 {
22     Complex temp;
23     temp.a = a + c.a;
24     temp.b = b + c.b;
25     return temp;
26 }
27 // main
28 int _tmain(int argc, _TCHAR* argv[])
29 {
30     Complex com1(1, 3), com2(2,4);
31     Complex total;
32     total = com1 + com2;
33     printf("total.a = %d, total.b = %d\n", total.a, total.b);
34     system("pause");
35     return 0;
36 }

咱們來比較如下成員運算符函數與友元運算符函數的差異：

對雙目運算符而言，成員運算符函數因爲有this指針，因此只帶有一個參數，而友元運算符函數帶有兩個參數。對單目運算符而言，成員運算符函數不帶參數，而友元運算符函數帶一個參數。