C++中預(yù)定義的運(yùn)算符的操作對象只能是基本數(shù)據(jù)類型，實際上，對于很多用戶自定義類型，也需要有類似的運(yùn)算操作。例如：
class complex
{
public:
complex(double r=0.0,double I=0.0){real=r;imag=I;}
void display();
private:
double real;
double imag;
};
complex a(10,20),b(5,8);
“a+b”運(yùn)算如何實現(xiàn)？這時候我們需要自己編寫程序來說明“+”在作用于complex類對象時，該實現(xiàn)什么樣的功能，這就是運(yùn)算符重載。運(yùn)算符重載是對已有的運(yùn)算符賦予多重含義，使同一個運(yùn)算符作用于不同類型的數(shù)據(jù)導(dǎo)致不同類型的行為。
運(yùn)算符重載的實質(zhì)是函數(shù)重載。在實現(xiàn)過程中，首先把指定的運(yùn)算表達(dá)式轉(zhuǎn)化為對運(yùn)算符函數(shù)的調(diào)用，運(yùn)算對象轉(zhuǎn)化為運(yùn)算符函數(shù)的實參，然后根據(jù)實參的類型來確定需要調(diào)用達(dá)標(biāo)函數(shù)，這個過程愛編譯過程中完成。
一、 運(yùn)算符重載的規(guī)則
運(yùn)算符重載規(guī)則如下：
①、 C++中的運(yùn)算符除了少數(shù)幾個之外，全部可以重載，而且只能重載C++中已有的運(yùn)算符。
②、 重載之后運(yùn)算符的優(yōu)先級和結(jié)合性都不會改變。
③、 運(yùn)算符重載是針對新類型數(shù)據(jù)的實際需要，對原有運(yùn)算符進(jìn)行適當(dāng)?shù)母脑臁Ｒ话銇碚f，重載的功能應(yīng)當(dāng)與原有功能相類似，不能改變原運(yùn)算符的操作對象個數(shù)，同時至少要有一個操作對象是自定義類型。
不能重載的運(yùn)算符只有五個，它們是：成員運(yùn)算符“.”、指針運(yùn)算符“*”、作用域運(yùn)算符“：：”、“sizeof”、條件運(yùn)算符“？：”。
運(yùn)算符重載形式有兩種，重載為類的成員函數(shù)和重載為類的友元函數(shù)。
運(yùn)算符重載為類的成員函數(shù)的一般語法形式為：
函數(shù)類型 operator 運(yùn)算符（形參表）
{
函數(shù)體；
}
運(yùn)算符重載為類的友元函數(shù)的一般語法形式為：
friend 函數(shù)類型 operator 運(yùn)算符（形參表）
{
函數(shù)體；
}
其中，函數(shù)類型就是運(yùn)算結(jié)果類型；operator是定義運(yùn)算符重載函數(shù)的關(guān)鍵字；運(yùn)算符是重載的運(yùn)算符名稱。
當(dāng)運(yùn)算符重載為類的成員函數(shù)時，函數(shù)的參數(shù)個數(shù)比原來的操作個數(shù)要少一個；當(dāng)重載為類的友元函數(shù)時，參數(shù)個數(shù)與原操作數(shù)個數(shù)相同。原因是重載為類的成員函數(shù)時，如果某個對象使用重載了的成員函數(shù)，自身的數(shù)據(jù)可以直接訪問，就不需要再放在參數(shù)表中進(jìn)行傳遞，少了的操作數(shù)就是該對象本身。而重載為友元函數(shù)時，友元函數(shù)對某個對象的數(shù)據(jù)進(jìn)行操作，就必須通過該對象的名稱來進(jìn)行，因此使用到的參數(shù)都要進(jìn)行傳遞，操作數(shù)的個數(shù)就不會有變化。
運(yùn)算符重載的主要優(yōu)點就是允許改變使用于系統(tǒng)內(nèi)部的運(yùn)算符的操作方式，以適應(yīng)用戶自定義類型的類似運(yùn)算。
二、 運(yùn)算符重載為成員函數(shù)
對于雙目運(yùn)算符B，如果要重載B為類的成員函數(shù)，使之能夠?qū)崿F(xiàn)表達(dá)式oprd1 B oprd2,其中oprd1為類A的對象，則應(yīng)當(dāng)把B重載為A類的成員函數(shù)，該函數(shù)只有一個形參，形參的類型是oprd2所屬的類型。經(jīng)過重載后，表達(dá)式oprd1 B oprd2 就相當(dāng)于函數(shù)調(diào)用oprd1.operator B(oprd2).
對于前置單目運(yùn)算符U，如“-”（負(fù)號）等，如果要重載U為類的成員函數(shù)，用來實現(xiàn)表達(dá)式U oprd，其中oprd為A類的對象，則U應(yīng)當(dāng)重載為A類的成員函數(shù)，函數(shù)沒有形參。經(jīng)過重載之后，表達(dá)式U oprd相當(dāng)于函數(shù)調(diào)用oprd.operator U().
對于后置運(yùn)算符“++”和“- -”，如果要將它們重載為類的成員函數(shù)，用來實現(xiàn)表達(dá)式oprd++或oprd--，其中oprd為A類的對象，那么運(yùn)算符就應(yīng)當(dāng)重載為A類的成員函數(shù)，這時函數(shù)要帶有一個整型形參。重載之后，表達(dá)式oprd++和oprd—就想當(dāng)于函數(shù)調(diào)用oprd.operator++(0)和oprd.operator—(0);
運(yùn)算符重載就是賦予已有的運(yùn)算符多重含義。通過重新定義運(yùn)算符，使它能夠用于特定類的對象執(zhí)行特定的功能，這便增強(qiáng)了C++語言的擴(kuò)充能力。
1. 運(yùn)算符重載的作用:
運(yùn)算符重載允許C/C++的運(yùn)算符在用戶定義類型(類)上擁有一個用戶定義的意義。重載的運(yùn)算符是函數(shù)調(diào)用的語法修飾：
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. 可以用作重載的運(yùn)算符:
算術(shù)運(yùn)算符：+,-,*,/,%,++,--;
位操作運(yùn)算符：&,|,~,^,＜＜,＞＞
邏輯運(yùn)算符：!,&&,||;
比較運(yùn)算符：＜,＞,＞=,＜=,==,!=;
賦值運(yùn)算符：=,+=,-=,*=,/=,%=,&=,|=,^=,＜＜=,＞＞=;
其他運(yùn)算符：[],(),-＞,,(逗號運(yùn)算符),new,delete,new[],delete[],-＞*。
下列運(yùn)算符不允許重載：
.,.*,::,?:
3. 運(yùn)算符重載后，優(yōu)先級和結(jié)合性:
用戶重載新定義運(yùn)算符，不改變原運(yùn)算符的優(yōu)先級和結(jié)合性。這就是說，對運(yùn)算符重載不改變運(yùn)算符的優(yōu)先級和結(jié)合性，并且運(yùn)算符重載后，也不改變運(yùn)算符的語法結(jié)構(gòu)，即單目運(yùn)算符只能重載為單目運(yùn)算符，雙目運(yùn)算符只能重載雙目運(yùn)算符。
4. 編譯程序如何選用哪一個運(yùn)算符函數(shù):
運(yùn)算符重載實際是一個函數(shù)，所以運(yùn)算符的重載實際上是函數(shù)的重載。編譯程序?qū)?strong style="BACKGROUND-COLOR: #ffff66; COLOR: black">運(yùn)算符重載的選擇，遵循著函數(shù)重載的選擇原則。當(dāng)遇到不很明顯的運(yùn)算時，編譯程序?qū)⑷ふ覅?shù)相匹配的運(yùn)算符函數(shù)。
5. 重載運(yùn)算符有哪些限制:
(1) 不可臆造新的運(yùn)算符。必須把重載運(yùn)算符限制在C++語言中已有的運(yùn)算符范圍內(nèi)的允許重載的運(yùn)算符之中。
(2) 重載運(yùn)算符堅持4個“不能改變”。
·不能改變運(yùn)算符操作數(shù)的個數(shù)；
·不能改變運(yùn)算符原有的優(yōu)先級；
·不能改變運(yùn)算符原有的結(jié)合性；
·不能改變運(yùn)算符原有的語法結(jié)構(gòu)。
6. 運(yùn)算符重載時必須遵循哪些原則:
運(yùn)算符重載可以使程序更加簡潔，使表達(dá)式更加直觀，增加可讀性。但是，運(yùn)算符重載使用不宜過多，否則會帶來一定的麻煩。
(1) 重載運(yùn)算符含義必須清楚。
(2) 重載運(yùn)算符不能有二義性。
運(yùn)算符重載函數(shù)的兩種形式
運(yùn)算符重載的函數(shù)一般地采用如下兩種形式：成員函數(shù)形式和友元函數(shù)形式。這兩種形式都可訪問類中的私有成員。
1. 重載為類的成員函數(shù)
這里先舉一個關(guān)于給復(fù)數(shù)運(yùn)算重載復(fù)數(shù)的四則運(yùn)算符的例子。復(fù)數(shù)由實部和虛部構(gòu)造，可以定義一個復(fù)數(shù)類，然后再在類中重載復(fù)數(shù)四則運(yùn)算的運(yùn)算符。先看以下源代碼：
#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;
}
該程序的運(yùn)行結(jié)果為：
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個成員函數(shù)作為運(yùn)算符重載函數(shù)。將運(yùn)算符重載函數(shù)說明為類的成員函數(shù)格式如下：
＜類名＞ operator ＜運(yùn)算符＞(＜參數(shù)表＞)
其中，operator是定義運(yùn)算符重載函數(shù)的關(guān)鍵字。
程序中出現(xiàn)的表達(dá)式：
c1+c2
編譯程序?qū)⒔o解釋為：
c1.operator+(c2)
其中，c1和c2是complex類的對象。operator+()是運(yùn)算+的重載函數(shù)。
該運(yùn)算符重載函數(shù)僅有一個參數(shù)c2。可見，當(dāng)重載為成員函數(shù)時，雙目運(yùn)算符僅有一個參數(shù)。對單目運(yùn)算符，重載為成員函數(shù)時，不能再顯式說明參數(shù)。重載為成員函數(shù)時，總時隱含了一個參數(shù)，該參數(shù)是this指針。this指針是指向調(diào)用該成員函數(shù)對象的指針。
2. 重載為友元函數(shù):
運(yùn)算符重載函數(shù)還可以為友元函數(shù)。當(dāng)重載友元函數(shù)時，將沒有隱含的參數(shù)this指針。這樣，對雙目運(yùn)算符，友元函數(shù)有2個參數(shù)，對單目運(yùn)算符，友元函數(shù)有一個參數(shù)。但是，有些運(yùn)行符不能重載為友元函數(shù)，它們是：=,(),[]和-＞。
重載為友元函數(shù)的運(yùn)算符重載函數(shù)的定義格式如下：
friend ＜類型說明符＞ operator ＜運(yùn)算符＞(＜參數(shù)表＞)
{……}
下面用友元函數(shù)代碼成員函數(shù)，重載編寫上述的例子，程序如下：
#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;
}
該程序的運(yùn)行結(jié)果與上例相同。前面已講過，對又目運(yùn)算符，重載為成員函數(shù)時，僅一個參數(shù)，另一個被隱含；重載為友元函數(shù)時，有兩個參數(shù)，沒有隱含參數(shù)。因此，程序中出現(xiàn)的 c1+c2
編譯程序解釋為：
operator+(c1, c2)
調(diào)用如下函數(shù)，進(jìn)行求值，
complex operator +(const coplex &c1, const complex &c2)
3. 兩種重載形式的比較
一般說來，單目運(yùn)算符最好被重載為成員；對雙目運(yùn)算符最好被重載為友元函數(shù)，雙目運(yùn)算符重載為友元函數(shù)比重載為成員函數(shù)更方便此，但是，有的雙目運(yùn)算符還是重載為成員函數(shù)為好，例如，賦值運(yùn)算符。因為，它如果被重載為友元函數(shù)，將會出現(xiàn)與賦值語義不一致的地方。 其他運(yùn)算符的重載舉例
1).下標(biāo)運(yùn)算符重載
由于C語言的數(shù)組中并沒有保存其大小，因此，不能對數(shù)組元素進(jìn)行存取范圍的檢查，無法保證給數(shù)組動態(tài)賦值不會越界。利用C++的類可以定義一種更安全、功能強(qiáng)的數(shù)組類型。為此，為該類定義重載運(yùn)算符[]。
下面一個例子：
#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;
}
該數(shù)組類的優(yōu)點如下：
(1) 其大小不一定是一個常量。
(2) 運(yùn)行時動態(tài)指定大小可以不用運(yùn)算符new和delete。
(3) 當(dāng)使用該類數(shù)組作函數(shù)參數(shù)時，不心分別傳遞數(shù)組變量本身及其大小，因為該對象中已經(jīng)保存大小。
在重載下標(biāo)運(yùn)算符函數(shù)時應(yīng)該注意：
(1) 該函數(shù)只能帶一個參數(shù)，不可帶多個參數(shù)。
(2) 不得重載為友元函數(shù)，必須是非static類的成員函數(shù)。 2). 重載增1減1運(yùn)算符.
增1減1運(yùn)算符是單目運(yùn)算符。它們又有前綴和后綴運(yùn)算兩種。為了區(qū)分這兩種運(yùn)算，將后綴運(yùn)算視為又目運(yùn)算符。表達(dá)式
obj++或obj--
被看作為：
obj++0或obj--0
下面舉一例子說明重載增1減1運(yùn)算符的應(yīng)用。
#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). 重載函數(shù)調(diào)用運(yùn)算符
可以將函數(shù)調(diào)用運(yùn)算符()看成是下標(biāo)運(yùn)算[]的擴(kuò)展。函數(shù)調(diào)用運(yùn)算符可以帶0個至多個參數(shù)。下面通過一個實例來熟悉函數(shù)調(diào)用運(yùn)算符的重載。
#include ＜iostream.h＞
class F
{
public:
double operator ()(double x, double y) const;
};
<span style="font-size:
