C++里面有一個叫作運算符重載的特性，它其實是基于函數(shù)實現(xiàn)的，下面就來介紹一下運算符重載。

1、What
　C++中預定義的運算符的操作對象只能是基本數(shù)據(jù)類型。但實際上，對于許多用戶自定義類型（例如類），也需要類似的運算操作。這時就必須在C++中重新定義這些運算符，賦予已有運算符新的功能，使它能夠用于特定類型執(zhí)行特定的操作。運算符重載的實質(zhì)是函數(shù)重載，它提供了C++的可擴展性，也是C++最吸引人的特性之一。
　　運算符重載函數(shù)的定義與其他函數(shù)的定義類似，惟一的區(qū)別是運算符重載函數(shù)的函數(shù)名是由關(guān)鍵字operator和其后要重載的運算符符號構(gòu)成的。運算符函數(shù)定義的一般格式如下：
　　返回值 opreator 運算符（參數(shù)列表）
　　{
　　　函數(shù)體
　　}
當然，并不是所有運算符都可以實現(xiàn)重載，下面列舉了能實現(xiàn)重載和不能實現(xiàn)重載的運算符。

2、Notice
a. 不能通過連接其他符號來創(chuàng)建新的操作符：比如operator@；
b. 重載操作符必須有一個類類型或者枚舉類型的操作數(shù)；

int operator +(const int _iNum1 , const int _iNum2 ) // 報錯{return ( _iNum1 + _iNum2);}typedef enum TEST {one ,two ,three };int operator+(const int _iNum1 , const TEST _test ) //正確{return _iNum1;}

c. 用于內(nèi)置類型的操作符，其含義不能改變，例如：內(nèi)置的整型+，不能改變其含義；
d. 不再具備短求值特性
重載操作符不能保證操作符的求值順序,在重載&&和||中，對每個操作數(shù)都要進行求值，而且對操作數(shù)的求值順序不能做規(guī)定，因此：重載&&、||和逗號操作符不是好的做法。
e. 作為類成員的重載函數(shù)，其形參看起來比操作數(shù)數(shù)目少1

成員函數(shù)的操作符有一個默認的形參this，限定為第一個形參。

CTest operator+(const CTest test1, const CTest test2)const // 報錯{return test1;}CTest operator+(const CTest test1)const{return test1;}

f. 一般將算術(shù)操作符定義為非成員函數(shù)，將賦值運算符定義成員函數(shù)
g. 操作符定義為非類的成員函數(shù)時，一般將其定義為類的友元
h. == 和 != 操作符一般要成對重載
i.下標操作符[]：一個非const成員并返回引用，一個是const成員并返回引用
j. 解引用操作符*和->操作符，不顯示任何參數(shù)
k. 自增自減操作符
前置式++/–必須返回被增量或者減量的引用
后綴式操作符必須返回舊值，并且應該是值返回而不是引用返回
l. 輸入操作符>>和輸出操作符<<必須定義為類的友元函數(shù)

3、Realize

通過一個復數(shù)類來深入認識運算符重載

#define _CRT_SECURE_NO_WARNINGS 1 #include <iostream> using namespace std;//實現(xiàn)復數(shù)類 class Complex { public:Complex(const double real = 0.0, const double image = 0.0):_real(real), _image(image){cout << "Create:" << this << endl;}Complex(const Complex& complex):_real(complex._real), _image(complex._image){cout << "Copy Create:" << this << endl;}~Complex(){cout << "Destroy:" << this << endl;}void Print(){cout << "real:" << _real << " image:" << _image << endl;}//實現(xiàn)各個運算符的重載//= + - * /Complex& operator=(const Complex& complex){if (this != &complex){_real = complex._real;_image = complex._image;}return *this;}Complex operator+(const Complex& complex){return Complex(_real + complex._real, _image + complex._image);}Complex operator-(const Complex& complex){return Complex(_real - complex._real, _image - complex._image);}Complex operator*(const Complex& complex){//復數(shù)乘法：(a+bi) * (c+di) = （ac-bd）+ (ad+bc)ireturn Complex((_real*complex._real - _image*complex._image), (_real*complex._image + _image*complex._real));}Complex operator/(const Complex& complex){//復數(shù)除法：(a+bi) / (c+di) = (ac+bd)/(c*c+d*d) + (bc-ad)i/(c*c+d*d)return Complex((_real*complex._real + _image*complex._image) / (complex._real*complex._real + complex._image*complex._image), \(_image*complex._real - _real*complex._image) / (complex._real*complex._real + complex._image*complex._image));}//+= -= *= /=Complex operator+=(const Complex& complex){_real += complex._real;_image += complex._image;return *this;}Complex operator-=(const Complex& complex){_real -= complex._real;_image -= complex._image;return *this;}Complex operator*=(const Complex& complex){//因為下面的運算中用到的都是_real和_image的初始值，所以在這兒先把它們的初始值保存下來（temp2可以不用定義直接用_image）double temp1 = _real;double temp2 = _image;_real = temp1*complex._real - temp2*complex._image;_image = temp1*complex._image + temp2*complex._real;return *this;}Complex operator/=(const Complex& complex){double temp1 = _real;double temp2 = _image;_real = (temp1*complex._real + temp2*complex._image) / (complex._real*complex._real + complex._image*complex._image);_image = (temp2*complex._real - temp1*complex._image) / (complex._real*complex._real + complex._image*complex._image);return *this;}//> >= < <= == !=bool operator>(const Complex& complex){return _real > complex._real;}bool operator>=(const Complex& complex){return _real >= complex._real;}bool operator<(const Complex& complex){return _real < complex._real;}bool operator<=(const Complex& complex){return _real <= complex._real;}//上面四個函數(shù)只比較實部是因為：復數(shù)實部不為0，那么此時它是一個虛數(shù)，無法比較大小，這兒只是為了說明這幾個運算符的//重載是如何實現(xiàn)的，沒有實際的邏輯意義bool operator ==(const Complex& complex){return (_real == complex._real) && (_image == complex._image);}bool operator !=(const Complex& complex){return (_real != complex._real) || (_image != complex._image);}//前置++ --Complex& operator++(){_real++;_image++;return *this;}Complex& operator--(){_real--;_image--;return *this;}//后置++ --Complex operator++(int){//因為后置的++和--，是先賦值，再++或--，所以這兒用一個臨時變量來記住變量的值，然后把該變量自加1，//此時變量的值已經(jīng)變了，但因為返回的是變量自加之前的值，所以整個表達式的值是該變量自加前的值Complex temp(*this);_real++;_image++;return temp;}Complex operator--(int){Complex temp(*this);_real--;_image--;return temp;}//邏輯運算 && || !bool operator&&(const Complex& complex){return ((_real != 0 || _image != 0) && (complex._real != 0 || complex._image != 0));}bool operator||(const Complex& complex){return ((_real != 0 || _image != 0) || (complex._real != 0 || complex._image != 0));}bool operator!(){return !(_real != 0 || _image != 0);} private:double _real;double _image; };//Test Complex() / Complex(const Complex& complex) / ~Complex() / Print() void TestFun1() {Complex c1;Complex c2(1.1, 2.2);Complex c3(c2);c1.Print();c2.Print();c3.Print(); }//Test operator= / operator+ / operator- / operator* / operator/ void TestFun2() {Complex c1(1.1, 2.2);Complex c2(1.1, 2.2);Complex c3(0.0, 0.0);c3 = c2;Complex c4 = c1 + c2;Complex c5 = c1 - c2;Complex c6 = c1 * c2;Complex c7 = c1 / c2;c1.Print();c2.Print();c3.Print();c4.Print();c5.Print();c6.Print();c7.Print(); }//Test operator+= / operator-= / operator*= / operator/= void TestFun3() {Complex c1(1.1, 2.2);Complex c2(0.0, 0.0);Complex c3(0.0, 0.0);Complex c4(1.0, 1.0);Complex c5(1.1, 2.2);c2 += c1;c3 -= c1;c4 *= c1;c5 /= c1;c1.Print();c2.Print();c3.Print();c4.Print();c5.Print(); }//Test operator> / operator>= / operator< / operator<= / operator== / operator!= void TestFun4() {Complex c1(1.1, 2.2);Complex c2(0.0, 0.0);bool b1 = c1 > c2;bool b2 = c1 >= c2;bool b3 = c1 < c2;bool b4 = c1 <= c2;bool b5 = c1 == c2;bool b6 = c1 != c2;cout << b1 << ' ' << b2 << ' ' << b3 << ' ' << b4 << ' ' << b5 << ' ' << b6 << endl; }//Test operator++() / operator++(int) / operator--() / operator--(int) void TestFun5() {Complex c1(1.1, 2.2);Complex c2(1.1, 2.2);Complex temp(0.0, 0.0);//因為要是直接用c1或c2輸出，那么在輸出時c1、c2的值已經(jīng)是++或--運算的下一次使用了，因此用temp記住使用前的值temp = ++c1;temp.Print();temp = c1++;temp.Print();temp = --c2;temp.Print();temp = c2--;temp.Print(); }//Test operator&& / operator|| / operator! void TestFun6() {Complex c1(1.1, 2.2);Complex c2(0.0, 0.0);bool b1 = c1 && c2;bool b2 = c1 || c2;bool b3 = !c2;cout << b1 << ' ' << ' ' << b2 << ' ' << b3 << endl; }int main() {//TestFun1();//TestFun2();TestFun3();//TestFun4();//TestFun5();//TestFun6();getchar();return 0; }

總結(jié)

以上是生活随笔為你收集整理的初识C++之运算符重载的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。