C++運算符重載探討
發(fā)表日期：2004-01-30 作者：阿青[] 出處：
前言
多態(tài)性是面向對象程序設計的重要特征之一。它與前面講過(guò)的封裝性和繼承性構成了面向對象程序設計的三大特征。這三大特征是相互關(guān)聯(lián)的。封裝性是基礎，繼承性是關(guān)鍵，多態(tài)性是補充，而多態(tài)又必須存在于繼承的環(huán)境之中。
所謂多態(tài)性是指發(fā)出同樣的消息被不同類(lèi)型的對象接收時(shí)導致完全不同的行為。這里所說(shuō)的消息主要是指對類(lèi)的成員函數的調用，而不同的行為是指不同的實(shí)現。 利用多態(tài)性，用戶(hù)只需發(fā)送一般形式的消息，而將所有的實(shí)現留給接收消息的對象。對象根據所接收到的消息而做出相應的動(dòng)作(即操作)。
函數重載和運算符重載是簡(jiǎn)單一類(lèi)多態(tài)性。函數重載的概念及用法在《函數重載》一講中已討論過(guò)了，這里只作簡(jiǎn)單的補充，我們重點(diǎn)討論的是運算符的重載。
所謂函數重載簡(jiǎn)單地說(shuō)就是賦給同一個(gè)函數名多個(gè)含義。具體地講，C++中允許在相同的作用域內以相同的名字定義幾個(gè)不同實(shí)現的函數，可以是成員函數，也 可以是非成員函數。但是，定義這種重載函數時(shí)要求函數的參數或者至少有一個(gè)類(lèi)型不同，或者個(gè)數不同。而對于返回值的類(lèi)型沒(méi)有要求，可以相同，也可以不同。 那種參數個(gè)數和類(lèi)型都相同，僅僅返回值不同的重載函數是非法的。因為編譯程序在選擇相同名字的重載函數時(shí)僅考慮函數表，這就是說(shuō)要靠函數的參數表中，參數 個(gè)數或參數類(lèi)型的差異進(jìn)行選擇。 由此可以看出，重載函數的意義在于它可以用相同的名字訪(fǎng)問(wèn)一組相互關(guān)聯(lián)的函數，由編譯程序來(lái)進(jìn)行選擇，因而這將有助于解決程序復雜性問(wèn)題。如：在定義類(lèi) 時(shí)，構造函數重載給初始化帶來(lái)了多種方式，為用戶(hù)提供更大的靈活性。
下面我們重點(diǎn)討論運算符重載。
運算符重載就是賦予已有的運算符多重含義。C++中通過(guò)重新定義運算符，使它能夠用于特定類(lèi)的對象執行特定的功能，這便增強了C++語(yǔ)言的擴充能力。
運算符重載的幾個(gè)問(wèn)題
1. 運算符重載的作用是什么？
它允許你為類(lèi)的用戶(hù)提供一個(gè)直覺(jué)的接口。
運算符重載允許C/C++的運算符在用戶(hù)定義類(lèi)型(類(lèi))上擁有一個(gè)用戶(hù)定義的意義。重載的運算符是函數調用的語(yǔ)法修飾：
class Fred
{
public:
// ...
};
#if 0
// 沒(méi)有算符重載：
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. 算符重載的好處是什么？
通過(guò)重載類(lèi)上的標準算符，你可以發(fā)掘類(lèi)的用戶(hù)的直覺(jué)。使得用戶(hù)程序所用的語(yǔ)言是面向問(wèn)題的，而不是面向機器的。
最終目標是降低學(xué)習曲線(xiàn)并減少錯誤率。
3. 哪些運算符可以用作重載？
幾乎所有的運算符都可用作重載。具體包含：
算術(shù)運算符：+,-,*,/,%,++,--;
位操作運算符：&,|,~,^,＜＜,＞＞
邏輯運算符：!,&&,||;
比較運算符：＜,＞,＞=,＜=,==,!=;
賦值運算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;
其他運算符：[],(),-＞,,(逗號運算符),new,delete,new[],delete[],-＞*。
下列運算符不允許重載：
.,.*,::,?:
4. 運算符重載后，優(yōu)先級和結合性怎么辦？
用戶(hù)重載新定義運算符，不改變原運算符的優(yōu)先級和結合性。這就是說(shuō)，對運算符重載不改變運算符的優(yōu)先級和結合性，并且運算符重載后，也不改變運算符的語(yǔ)法結構，即單目運算符只能重載為單目運算符，雙目運算符只能重載雙目運算符。
5. 編譯程序如何選用哪一個(gè)運算符函數？
運算符重載實(shí)際是一個(gè)函數，所以運算符的重載實(shí)際上是函數的重載。編譯程序對運算符重載的選擇，遵循著(zhù)函數重載的選擇原則。當遇到不很明顯的運算時(shí)，編譯程序將去尋找參數相匹配的運算符函數。
6. 重載運算符有哪些限制？
(1) 不可臆造新的運算符。必須把重載運算符限制在C++語(yǔ)言中已有的運算符范圍內的允許重載的運算符之中。
(2) 重載運算符堅持4個(gè)“不能改變”。
·不能改變運算符操作數的個(gè)數；
·不能改變運算符原有的優(yōu)先級；
·不能改變運算符原有的結合性；
·不能改變運算符原有的語(yǔ)法結構。
7. 運算符重載時(shí)必須遵循哪些原則？
運算符重載可以使程序更加簡(jiǎn)潔，使表達式更加直觀(guān)，增加可讀性。但是，運算符重載使用不宜過(guò)多，否則會(huì )帶來(lái)一定的麻煩。
使用重載運算符時(shí)應遵循如下原則：
(1) 重載運算符含義必須清楚。
(2) 重載運算符不能有二義性。
運算符重載函數的兩種形式
運算符重載的函數一般地采用如下兩種形式：成員函數形式和友元函數形式。這兩種形式都可訪(fǎng)問(wèn)類(lèi)中的私有成員。
1. 重載為類(lèi)的成員函數
這里先舉一個(gè)關(guān)于給復數運算重載復數的四則運算符的例子。復數由實(shí)部和虛部構造，可以定義一個(gè)復數類(lèi)，然后再在類(lèi)中重載復數四則運算的運算符。先看以下源代碼：
#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
在程序中，類(lèi)complex定義了4個(gè)成員函數作為運算符重載函數。將運算符重載函數說(shuō)明為類(lèi)的成員函數格式如下：
＜類(lèi)名＞ operator ＜運算符＞(＜參數表＞)
其中，operator是定義運算符重載函數的關(guān)鍵字。
程序中出現的表達式：
c1+c2
編譯程序將給解釋為：
c1.operator+(c2)
其中，c1和c2是complex類(lèi)的對象。operator+()是運算+的重載函數。
該運算符重載函數僅有一個(gè)參數c2?？梢?jiàn)，當重載為成員函數時(shí)，雙目運算符僅有一個(gè)參數。對單目運算符，重載為成員函數時(shí)，不能再顯式說(shuō)明參數。重載為成員函數時(shí)，總時(shí)隱含了一個(gè)參數，該參數是this指針。this指針是指向調用該成員函數對象的指針。
2. 重載為友元函數
運算符重載函數還可以為友元函數。當重載友元函數時(shí)，將沒(méi)有隱含的參數this指針。這樣，對雙目運算符，友元函數有2個(gè)參數，對單目運算符，友元函數有一個(gè)參數。但是，有些運行符不能重載為友元函數，它們是：=,(),[]和-＞。
重載為友元函數的運算符重載函數的定義格式如下：
friend ＜類(lèi)型說(shuō)明符＞ operator ＜運算符＞(＜參數表＞)
{……}
下面用友元函數代碼成員函數，重載編寫(xiě)上述的例子，程序如下：
#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;
}
該程序的運行結果與上例相同。前面已講過(guò)，對又目運算符，重載為成員函數時(shí)，僅一個(gè)參數，另一個(gè)被隱含；重載為友元函數時(shí)，有兩個(gè)參數，沒(méi)有隱含參數。因此，程序中出現的 c1+c2
編譯程序解釋為：
operator+(c1, c2)
調用如下函數，進(jìn)行求值，
complex operator +(const coplex &c1, const complex &c2)
3. 兩種重載形式的比較
一般說(shuō)來(lái)，單目運算符最好被重載為成員；對雙目運算符最好被重載為友元函數，雙目運算符重載為友元函數比重載為成員函數更方便此，但是，有的雙目運算符 還是重載為成員函數為好，例如，賦值運算符。因為，它如果被重載為友元函數，將會(huì )出現與賦值語(yǔ)義不一致的地方。 其他運算符的重載舉例
1).下標運算符重載
由于C語(yǔ)言的數組中并沒(méi)有保存其大小，因此，不能對數組元素進(jìn)行存取范圍的檢查，無(wú)法保證給數組動(dòng)態(tài)賦值不會(huì )越界。利用C++的類(lèi)可以定義一種更安全、功能強的數組類(lèi)型。為此，為該類(lèi)定義重載運算符[]。
下面先看看一個(gè)例子：
#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;
}
該數組類(lèi)的優(yōu)點(diǎn)如下：
(1) 其大小不心是一個(gè)常量。
(2) 運行時(shí)動(dòng)態(tài)指定大小可以不用運算符new和delete。
(3) 當使用該類(lèi)數組作函數參數時(shí)，不心分別傳遞數組變量本身及其大小，因為該對象中已經(jīng)保存大小。
在重載下標運算符函數時(shí)應該注意：
(1) 該函數只能帶一個(gè)參數，不可帶多個(gè)參數。
(2) 不得重載為友元函數，必須是非static類(lèi)的成員函數。 2). 重載增1減1運算符
增1減1運算符是單目運算符。它們又有前綴和后綴運算兩種。為了區分這兩種運算，將后綴運算視為又目運算符。表達式
obj++或obj--
被看作為：
obj++0或obj--0
下面舉一例子說(shuō)明重載增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個(gè)至多個(gè)參數。下面通過(guò)一個(gè)實(shí)例來(lái)熟悉函數調用運算符的重載。
#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;
}
