C++運算符重載探討

2019-11-17 05:25:53

字體：大中小

來源：轉載

供稿：網友

前言

　　多態性是面向對象程序設計的重要特征之一。它與前面講過的封裝性和繼續性構成了面向對象程序設計的三大特征。這三大特征是相互關聯的。封裝性是基礎，繼續性是要害，多態性是補充，而多態又必須存在于繼續的環境之中。

　　所謂多態性是指發出同樣的消息被不同類型的對象接收時導致完全不同的行為。這里所說的消息主要是指對類的成員函數的調用，而不同的行為是指不同的實現。利用多態性，用戶只需發送一般形式的消息，而將所有的實現留給接收消息的對象。對象根據所接收到的消息而做出相應的動作(即操作)。

　　函數重載和運算符重載是簡單一類多態性。函數重載的概念及用法在《函數重載》一講中已討論過了，這里只作簡單的補充，我們重點討論的是運算符的重載。

　　所謂函數重載簡單地說就是賦給同一個函數名多個含義。具體地講，C++中答應在相同的作用域內以相同的名字定義幾個不同實現的函數，可以是成員函數，也可以是非成員函數。但是，定義這種重載函數時要求函數的參數或者至少有一個類型不同，或者個數不同。而對于返回值的類型沒有要求，可以相同，也可以不同。那種參數個數和類型都相同，僅僅返回值不同的重載函數是非法的。因為編譯程序在選擇相同名字的重載函數時僅考慮函數表，這就是說要靠函數的參數表中，參數個數或參數類型的差異進行選擇。由此可以看出，重載函數的意義在于它可以用相同的名字訪問一組相互關聯的函數，由編譯程序來進行選擇，因而這將有助于解決程序復雜性問題。如：在定義類時，構造函數重載給初始化帶來了多種方式，為用戶提供更大的靈活性。

　　下面我們重點討論運算符重載。

　　運算符重載就是賦予已有的運算符多重含義。C++中通過重新定義運算符，使它能夠用于特定類的對象執行特定的功能，這便增強了C++語言的擴充能力。

　　運算符重載的幾個問題

　　1. 運算符重載的作用是什么？

　　它答應你為類的用戶提供一個直覺的接口。

　　運算符重載答應C/C++的運算符在用戶定義類型(類)上擁有一個用戶定義的意義。重載的運算符是函數調用的語法修飾：

class Fred
{
public:
// ...
};

#if 0
// 沒有算符重載：
Fred add(Fred, Fred);
Fred mul(Fred, Fred);

Fred f(Fred a, Fred b, Fred c)
{
return add(add(mul(a,b), mul(b,c)), mul(c,a)); // 哈哈，多可笑...
}
#else
// 有算符重載：
Fred Operator+ (Fred, Fred);
Fred operator* (Fred, Fred);

Fred f(Fred a, Fred b, Fred c)
{
return a*b + b*c + c*a;
}
#endif
　　2. 算符重載的好處是什么？

　　通過重載類上的標準算符，你可以發掘類的用戶的直覺。使得用戶程序所用的語言是面向問題的，而不是面向機器的。

　　最終目標是降低學習曲線并減少錯誤率。

　　3. 哪些運算符可以用作重載？

　　幾乎所有的運算符都可用作重載。具體包含：

　　算術運算符：+,-,*,/,%,++,--;
　　位操作運算符：&,,~,^,＜＜,＞＞
　　邏輯運算符：!,&&,;
　　比較運算符：＜,＞,＞=,＜=,==,!=;
　　賦值運算符：=,+=,-=,*=,/=,%=,&=,=,^=,＜＜=,＞＞=;
　　其他運算符：[],(),-＞,,(逗號運算符),new,delete,new[],delete[],-＞*。

　　下列運算符不答應重載：

　　.,.*,::,?:

　　4. 運算符重載后，優先級和結合性怎么辦？

　　用戶重載新定義運算符，不改變原運算符的優先級和結合性。這就是說，對運算符重載不改變運算符的優先級和結合性，并且運算符重載后，也不改變運算符的語法結構，即單目運算符只能重載為單目運算符，雙目運算符只能重載雙目運算符。

　　5. 編譯程序如何選用哪一個運算符函數？

　　運算符重載實際是一個函數，所以運算符的重載實際上是函數的重載。編譯程序對運算符重載的選擇，遵循著函數重載的選擇原則。當碰到不很明顯的運算時，編譯程序將去尋找參數相匹配的運算符函數。

　　6. 重載運算符有哪些限制？

　　(1) 不可臆造新的運算符。必須把重載運算符限制在C++語言中已有的運算符范圍內的答應重載的運算符之中。

　　(2) 重載運算符堅持4個“不能改變”。

　　·不能改變運算符操作數的個數；
　　·不能改變運算符原有的優先級；
　　·不能改變運算符原有的結合性；
　　·不能改變運算符原有的語法結構。

　　7. 運算符重載時必須遵循哪些原則？

　　運算符重載可以使程序更加簡潔，使表達式更加直觀，增加可讀性。但是，運算符重載使用不宜過多，否則會帶來一定的麻煩。

　　使用重載運算符時應遵循如下原則：

　　(1) 重載運算符含義必須清楚。

　　(2) 重載運算符不能有二義性。運算符重載函數的兩種形式

　　運算符重載的函數一般地采用如下兩種形式：成員函數形式和友元函數形式。這兩種形式都可訪問類中的私有成員。

　　1. 重載為類的成員函數

　　這里先舉一個關于給復數運算重載復數的四則運算符的例子。復數由實部和虛部構造，可以定義一個復數類，然后再在類中重載復數四則運算的運算符。先看以下源代碼：

#include ＜iostream.h＞

class complex
{
public:
complex() { real=imag=0; }
complex(double r, double i)
{
real = r, imag = i;
}
complex operator +(const complex &c);
complex operator -(const complex &c);
complex operator *(const complex &c);
complex operator /(const complex &c);
friend void PRint(const complex &c);
private:
double real, imag;
};

inline complex complex::operator +(const complex &c)
{
return complex(real + c.real, imag + c.imag);
}

inline complex complex::operator -(const complex &c)
{
return complex(real - c.real, imag - c.imag);
}

inline complex complex::operator *(const complex &c)
{
return complex(real * c.real - imag * c.imag, real * c.imag + imag * c.real);
}

inline complex complex::operator /(const complex &c)
{
return complex((real * c.real + imag + c.imag) / (c.real * c.real + c.imag * c.imag),
(imag * c.real - real * c.imag) / (c.real * c.real + c.imag * c.imag));
}

void print(const complex &c)
{
if(c.imag＜0)
cout＜＜c.real＜＜c.imag＜＜'i';
else
cout＜＜c.real＜＜'+'＜＜c.imag＜＜'i';
}

void main()
{
complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
c3 = c1 + c2;
cout＜＜"/nc1+c2=";
print(c3);
c3 = c1 - c2;
cout＜＜"/nc1-c2=";
print(c3);
c3 = c1 * c2;
cout＜＜"/nc1*c2=";
print(c3);
c3 = c1 / c2;
cout＜＜"/nc1/c2=";
print(c3);
c3 = (c1+c2) * (c1-c2) * c2/c1;
cout＜＜"/n(c1+c2)*(c1-c2)*c2/c1=";
print(c3);
cout＜＜endl;
}
　　該程序的運行結果為：

c1+c2=6+1i
c1-c2=-2+5i
c1*c2=14+8i
c1/c2=0.45+0.8i
(c1+c2)*(c1-c2)*c2/c1=9.61538+25.2308i
　　在程序中，類complex定義了4個成員函數作為運算符重載函數。將運算符重載函數說明為類的成員函數格式如下：

　　＜類名＞ operator ＜運算符＞(＜參數表＞)

　　其中，operator是定義運算符重載函數的要害字。

　　程序中出現的表達式：

　　c1+c2

　　編譯程序將給解釋為：

　　c1.operator+(c2)

　　其中，c1和c2是complex類的對象。operator+()是運算+的重載函數。

　　該運算符重載函數僅有一個參數c2。可見，當重載為成員函數時，雙目運算符僅有一個參數。對單目運算符，重載為成員函數時，不能再顯式說明參數。重載為成員函數時，總時隱含了一個參數，該參數是this指針。this指針是指向調用該成員函數對象的指針。

　　2. 重載為友元函數

　　運算符重載函數還可以為友元函數。當重載友元函數時，將沒有隱含的參數this指針。這樣，對雙目運算符，友元函數有2個參數，對單目運算符，友元函數有一個參數。但是，有些運行符不能重載為友元函數，它們是：=,(),[]和-＞。

　　重載為友元函數的運算符重載函數的定義格式如下：

　　friend ＜類型說明符＞ operator ＜運算符＞(＜參數表＞)
　　{……}

　　下面用友元函數代碼成員函數，重載編寫上述的例子，程序如下：

#include ＜iostream.h＞

class complex
{
public:
complex() { real=imag=0; }
complex(double r, double i)
{
real = r, imag = i;
}
friend complex operator +(const complex &c1, const complex &c2);
friend complex operator -(const complex &c1, const complex &c2);
friend complex operator *(const complex &c1, const complex &c2);
friend complex operator /(const complex &c1, const complex &c2);
friend
void print(const complex &c);
private:
double real, imag;
};

complex operator +(const complex &c1, const complex &c2)
{
return complex(c1.real + c2.real, c1.imag + c2.imag);
}

complex operator -(const complex &c1, const complex &c2)
{
return complex(c1.real - c2.real, c1.imag - c2.imag);
}

complex operator *(const complex &c1, const complex &c2)
{
return complex(c1.real * c2.real - c1.imag * c2.imag, c1.real * c2.imag + c1.imag * c2.real);
}

complex operator /(const complex &c1, const complex &c2)
{
return complex((c1.real * c2.real + c1.imag + c2.imag) / (c2.real * c2.real + c2.imag * c2.imag),
(c1.imag * c2.real - c1.real * c2.imag) / (c2.real * c2.real + c2.imag * c2.imag));
}

void print(const complex &c)
{
if(c.imag＜0)
cout＜＜c.real＜＜c.imag＜＜'i';
else
cout＜＜c.real＜＜'+'＜＜c.imag＜＜'i';
}

void main()
{
complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
c3 = c1 + c2;
cout＜＜"/nc1+c2=";
print(c3);
c3 = c1 - c2;
cout＜＜"/nc1-c2=";
print(c3);
c3 = c1 * c2;
cout＜＜"/nc1*c2=";
print(c3);
c3 = c1 / c2;
cout＜＜"/nc1/c2=";
print(c3);
c3 = (c1+c2) * (c1-c2) * c2/c1;
cout＜＜"/n(c1+c2)*(c1-c2)*c2/c1=";
print(c3);
cout＜＜endl;
}
　　該程序的運行結果與上例相同。前面已講過，對又目運算符，重載為成員函數時，僅一個參數，另一個被隱含；重載為友元函數時，有兩個參數，沒有隱含參數。因此，程序中出現的 c1+c2

　　編譯程序解釋為：

　　operator+(c1, c2)

　　調用如下函數，進行求值，

　　complex operator +(const coplex &c1, const complex &c2)
3. 兩種重載形式的比較

　　一般說來，單目運算符最好被重載為成員；對雙目運算符最好被重載為友元函數，雙目運算符重載為友元函數比重載為成員函數更方便此，但是，有的雙目運算符還是重載為成員函數為好，例如，賦值運算符。因為，它假如被重載為友元函數，將會出現與賦值語義不一致的地方。其他運算符的重載舉例

　　1).下標運算符重載

　　由于C語言的數組中并沒有保存其大小，因此，不能對數組元素進行存取范圍的檢查，無法保證給數組動態賦值不會越界。利用C++的類可以定義一種更安全、功能強的數組類型。為此，為該類定義重載運算符[]。

　　下面先看看一個例子：

#include ＜iostream.h＞

class CharArray
{
public:
CharArray(int l)
{
Length = l;
Buff = new char[Length];
}
~CharArray() { delete Buff; }
int GetLength() { return Length; }
char & operator [](int i);
private:
int Length;
char * Buff;
};

char & CharArray::operator [](int i)
{
static char ch = 0;
if(i＜Length&&i＞=0)
return Buff[i];
else
{
cout＜＜"/nIndex out of range.";
return ch;
}
}

void main()
{
int cnt;
CharArray string1(6);
char * string2 = "string";
for(cnt=0; cnt＜8; cnt++)
string1[cnt] = string2[cnt];
cout＜＜"/n";
for(cnt=0; cnt＜8; cnt++)
cout＜＜string1[cnt];
cout＜＜"/n";
cout＜＜string1.GetLength()＜＜endl;
}
　　該數組類的優點如下：

　　(1) 其大小不心是一個常量。
　　(2) 運行時動態指定大小可以不用運算符new和delete。
　　(3) 當使用該類數組作函數參數時，不心分別傳遞數組變量本身及其大小，因為該對象中已經保存大小。

　　在重載下標運算符函數時應該注重：

　　(1) 該函數只能帶一個參數，不可帶多個參數。
　　(2) 不得重載為友元函數，必須是非static類的成員函數。 2). 重載增1減1運算符

　　增1減1運算符是單目運算符。它們又有前綴和后綴運算兩種。為了區分這兩種運算，將后綴運算視為又目運算符。表達式

　　obj++或obj--

　　被看作為：

　　obj++0或obj--0

　　下面舉一例子說明重載增1減1運算符的應用。

#include ＜iostream.h＞

class counter
{
public:
counter() { v=0; }
counter operator ++();
counter operator ++(int );
void print() { cout＜＜v＜＜endl; }
private:
unsigned v;
};

counter counter::operator ++()
{
v++;
return *this;
}

counter counter::operator ++(int)
{
counter t;
t.v = v++;
return t;
}

void main()
{
counter c;
for(int i=0; i＜8; i++)
c++;
c.print();
for(i=0; i＜8; i++)
++c;
c.print();
}
　　3). 重載函數調用運算符

　　可以將函數調用運算符()看成是下標運算[]的擴展。函數調用運算符可以帶0個至多個參數。下面通過一個實例來熟悉函數調用運算符的重載。

#include ＜iostream.h＞

class F
{
public:
double operator ()(double x, double y) const;
};

double F::operator ()(double x, double y) const
{
return (x+5)*y;
}

void main()
{
F f;
cout＜＜f(1.5, 2.2)＜＜endl;
}

上一篇：C/C++指針應用

下一篇：C++ 通過WIN32 API 獲取邏輯磁盤詳細信息