前言

    　　多態(tài)性是面向?qū)ο蟪绦蛟O(shè)計的重要特征之一。它與前面講過的封裝性和繼承性構(gòu)成了面向?qū)ο蟪绦蛟O(shè)計的三大特征。這三大特征是相互關(guān)聯(lián)的。封裝性是基礎(chǔ)，繼承性是關(guān)鍵，多態(tài)性是補(bǔ)充，而多態(tài)又必須存在于繼承的環(huán)境之中。

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

    　　函數(shù)重載和運(yùn)算符重載是簡單一類多態(tài)性。函數(shù)重載的概念及用法在《函數(shù)重載》一講中已討論過了，這里只作簡單的補(bǔ)充，我們重點(diǎn)討論的是運(yùn)算符的重載。

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

    　　下面我們重點(diǎn)討論運(yùn)算符重載。

    　　運(yùn)算符重載就是賦予已有的運(yùn)算符多重含義。C++中通過重新定義運(yùn)算符，使它能夠用于特定類的對象執(zhí)行特定的功能，這便增強(qiáng)了C++語言的擴(kuò)充能力。

    　　運(yùn)算符重載的幾個問題

    　　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. 算符重載的好處是什么？

    　　通過重載類上的標(biāo)準(zhǔn)算符，你可以發(fā)掘類的用戶的直覺。使得用戶程序所用的語言是面向問題的，而不是面向機(jī)器的。

    　　最終目標(biāo)是降低學(xué)習(xí)曲線并減少錯誤率。

    　　3. 哪些運(yùn)算符可以用作重載？

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

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

    　　下列運(yùn)算符不允許重載：

    　　.,.*,::,?:

    　　4. 運(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)算符。

    　　5. 編譯程序如何選用哪一個運(yùn)算符函數(shù)？

    　　運(yùn)算符重載實際是一個函數(shù)，所以運(yùn)算符的重載實際上是函數(shù)的重載。編譯程序?qū)\(yùn)算符重載的選擇，遵循著函數(shù)重載的選擇原則。當(dāng)遇到不很明顯的運(yùn)算時，編譯程序?qū)⑷ふ覅?shù)相匹配的運(yùn)算符函數(shù)。

    　　6. 重載運(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)。

    　　7. 運(yùn)算符重載時必須遵循哪些原則？

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

    　　使用重載運(yùn)算符時應(yīng)遵循如下原則：

    　　(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)點(diǎn)如下：

    　　(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();
    }
    　　4). 重載函數(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;
    };

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

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