Performanced C++ 經驗規則（5）：再談重載、覆蓋和隱藏

1、首先說的是重載，有一個前提必須要弄清楚的是，如果不在類作用域內進行討論，兩個（或多個）同名函數之間的關系只可能是重載或隱藏，這里先說重載。考慮以下事實：

int foo(char c){...}
void foo(int x){...}

這兩個函數之間的關系是重載（overload），即相同函數名但參數不同，并注意返回類型是否相同并不會對重載產生任何影響。

也就是說，如果僅僅是返回類型不相同，而函數名和參數都完全相同的兩個函數，不能構成重載，編譯器會告知”ambiguous”（二義性）等詞以表達其不滿：

//Can't be compiled!

int fooo(char c){...}
void fooo(char c){...}

char c = 'A';
fooo(c); // Which one? ambiguous

在第四條中，已經講述過，重載是編譯期綁定的靜態行為，不是真正的多態性，那么，編譯器是根據什么來進行靜態綁定呢？又是如何確定兩個（或多個）函數之間的關系是重載呢？

有以下判定依據：

（1）相同的范圍：即作用域，這里指在同一個類中，或同一個名字空間，即C++的函數重載不支持跨越作用域進行（讀者可再次對比Java在這問題上的神奇處理，既上次Java給我們提供了未卜先知的動態綁定能力后，Java超一流的意識和大局觀再次給Java程序員提供了跨類重載的能力，如有興趣可詳細閱讀《Thinking in Java》的相關章節，其實對于學好C++來講，去學一下Java是很有幫助的，它會告訴你，同樣或類似的問題，為什么Java要做這樣的改進），這也是區別重載和隱藏的最重要依據。

關于“C++不能支持跨類重載”，稍后筆者會給出代碼來例證這一點。

（2）函數名字相同（基本前提）

（3）函數參數不同（基本前提，否則在同一作用域內有兩個或多個同名同參數的函數，將產生ambiguous，另外注意，對于成員函數，是否是const成員函數，即函數聲明之后是否帶有const標志， 可理解為“參數不同“），第（2）和第（3）點統稱“函數特征標”不同

（4）virtual關鍵字可有可無不產生影響（因為第（1）點已經指出，這是在同一個類中）

即“相同的范圍，特征標不同（當然同名是肯定的），發生重載“。

2、覆蓋（override），真正的多態行為，通過虛函數來實現，所以，編譯器根據以下依據來進行判定兩個（注意只可能是兩個，即使在繼承鏈中，也只是最近兩個為一組）函數之間的關系是覆蓋：

（1）不同的范圍：即使用域，兩個函數分別位于基類和派生類中

（2）函數名字相同（基本前提）

（3）函數參數也相同（基本前提），第（2）和第（3）點統稱“函數特征標”相同

（4）基類函數必須用virtual關鍵字修飾

即“不同的范圍，特征標相同，且基類有virtual聲明，發生覆蓋“。

3、隱藏（Hide），即：

（1）如果派生類函數與基類函數同名，但參數不同（特征標不同），此時，無論是否有virtual關鍵字，基類的所有同名函數都將被隱藏，而不會重載，因為不在同一個類中；

（2）如果派生類函數與基類函數同名，且參數也相同（特征標相同），但基類函數沒有用virtual關鍵字聲明，則基類的所有同名函數都將被隱藏，而不會覆蓋，因為沒有聲明為虛函數。

即“不同的范圍，特征標不同（當然同名是肯定的），發生隱藏”，或“不同的范圍，特征標相同，但基類沒有virtual聲明，發生隱藏“。

可見有兩種產生隱藏的情況，分別對應不能滿足重載和覆蓋條件的情況。

另外必須要注意的是，在類外討論時，也可能發生隱藏，如在名字空間中，如下述代碼所示：

#include <iostream>
using namespace std;

void foo(void) { cout << "global foo()" << endl; }
int foo(int x) { cout << "global foo(int)" << endl; return x; }
namespace a
{
        void foo(void) { cout << "a::foo()" << endl; }
        void callFoo(void) 
        { foo();
           // foo(10); Can't be compiled! }
}

int main(int argc, char** argv)
{
        foo();
        a::callFoo();
        return 0;
}

輸出結果：

global foo()
a::foo()

注意，名字空間a中的foo隱藏了其它作用域（這里是全局作用域）中的所有foo名稱，foo(10)不能通過編譯，因為全局作用域中的int foo(int)版本也已經被a::foo()隱藏了，除非使用::foo(10)顯式進行調用。

這也告訴我們，無論何時，都使用完整名稱修飾（作用域解析符調用函數，或指針、對象調用成員函數）是一種好的編程習慣。

 好了，上面零零散散說了太多理論的東西，我們需要一段實際的代碼，來驗證上述所有的結論：

#include <iostream>
using namespace std;

class Other
{
        void* p;
};

class Base
{
public:
        int iBase;
        Base():iBase(10){}
        virtual void f(int x = 20){ cout << "Base::f()--" << x << endl; }
        virtual void g(float f) { cout << "Base::g(float)--" << f << endl; }
        void g(Other& o) { cout << "Base::g(Other&)" << endl; }
        void g(Other& o) const { cout << "Base::g(Other&) const" << endl;}
};

class Derived : public Base
{
public:
        int iDerived;
        Derived():iDerived(100){}
        void f(int x = 200){ cout << "Derived::f()--" << x << endl; }
        virtual void g(int x) { cout << "Derived::g(int)--" << x << endl; }
};

int main(int argc, char** argv)
{
        Base* pBase = NULL;
        Derived* pDerived = NULL;
        Base b;
        Derived d;
        pBase = &b;
        pDerived = &d;
        Base* pBD = &d;
        const Base* pC = &d;
        const Base* const pCCP = &d;
        Base* const pCP = &d;

        int x = 5;
        Other o;
        float f = 3.1415926;

        b.f();
        pBase->f();
        d.f();
        pDerived->f();
        pBD->f();

        b.g(x);
        b.g(o);
        d.g(x);
        d.g(f);
        // Can't be compiled!
        // d.g(o);

        pBD->g(x);
        pBD->g(f);
        pC->g(o);
        pCCP->g(o);
        pCP->g(o);

        return 0;
}

在筆者Ubuntu 12.04 + gcc 4.6.3運行結果：

Base::f()--20 //b.f()，通過對象調用，無虛特性，靜態綁定
Base::f()--20 //基類指針指向基類對象，雖然是動態綁定，但沒有使用到覆蓋
Derived::f()--200 //d.f，通過對象調用，無虛特性，靜態綁定
Derived::f()--200 //子類指針指向子類對象，雖然是動態綁定，但沒有使用到覆蓋
Derived::f()--20 //基類指針指向子類對象，動態綁定，子類f()覆蓋基類版本。但函數參數默認值，是靜態聯編行為，pBD的類型是基類指針，所以使用了基類的參數默認值，注意此處！

Base::g(float)--5 //通過對象調用，int被提升為float
Base::g(Other&) //沒什么問題，基類中三個g函數之間的關系是重載
Derived::g(int)--5 //沒什么問題
Derived::g(int)--3 //注意基類的g(float)已經被隱藏！所以傳入的float參數調用的卻是子類的g(int)方法！

Base::g(float)--5 //注意！pBD是基類指針，雖然它指向了子類對象，但基類中的所有g函數版本它是可見的！所以pBD->g(5)調用到了g(float)！雖然產生了動態聯編也發生了隱藏，但子類對象的虛表中，仍可以找到g(float)的地址，即基類版本！
Base::g(float)--3.14159 //原理同上

//d.g(o)
//注意此處！再注意代碼中被注釋了的一行，d.g(o)不能通過編譯，因為d是子類對象，在子類中，基類中定義的三個g函數版本都被隱藏了，編譯時不可見！不會重載

Base::g(Other&) const //pC是指向const對象的指針，將調用const版本的g函數
Base::g(Other&) const //pCCP是指向const對象的const指針，也調用const版本的g函數
Base::g(Other&) //pCP是指向非cosnt對象的const指針，由于不指向const對象，調用非const版本的g函數

上述結果，是否和預想的是否又有些出入呢？問題主要集中于結果的第5、12、13和15行。

第5行輸出結果證明：當函數參數有默認值，又發生多態行為時，函數參數默認值是靜態行為，在編譯時就已經確定，將使用基類版本的函數參數默認值而不是子類的。

而第12、13、15行輸出結果則說明，盡管已經證明我們之前說的隱藏是正確的（因為d.g(o)不可以通過編譯，確實發生了隱藏），但卻可以利用基類指針指向派生類對象后，來繞開這種限制！也就是說，編譯器根據參數匹配函數原型的時候，是在編譯時根據指針的類型，或對象的類型來確定，指針類型是基類，那么基類中的g函數版本就是可見的；指針類型是子類，由于發生了隱藏，基類中的g函數版本就是不可見的。而到動態綁定時，基類指針指向了子類對象，在子類對象的虛函數表中，就可以找到基類中g虛函數的地址。

寫到這里，不知道讀者是否已經明白，這些繞來繞去的關系。在實際代碼運用中，可能并不會寫出含有這么多“陷阱”的測試代碼，我們只要弄清楚重載、覆蓋和隱藏的具體特征，并頭腦清醒地知道，我現在需要的是哪一種功能（通常也不會需要隱藏），就能寫出清析的代碼。上面的代碼其實是一個糟糕的例子，因為在這個例子中，重載、覆蓋、隱藏并存，我們編寫代碼，就是要盡可能防止這種含混不清的情況發生。

記住一個原則：每一個方法，功能和職責盡可能單一，否則，嘗試將它拆分成為多個方法。