在C++中，無論在類作用域內還是外，兩個（或多個）同名的函式，可能且僅可能是以下三種關係：過載（Overload）、覆蓋（Override）和隱藏（Hide），因為同名，區分這些關係則是根據引數是否相同、是否帶有const成員函式性質、是否有virtual關鍵字修飾以及是否在同一作用域來判斷。在第四條中，我們曾提到了一些關於過載、覆蓋的概念，但只是一帶而過，也沒有提到隱藏，這一篇我們將詳細討論。
1、首先說的是過載，有一個前提必須要弄清楚的是，如果不在類作用域內進行討論，兩個（或多個）同名函式之間的關係只可能是過載或隱藏，這裡先說過載。考慮以下事實：
|
1 2 |
int foo(char c){...} void foo(int x){...} |
這兩個函式之間的關係是過載（overload），即相同函式名但引數不同，並注意返回型別是否相同並不會對過載產生任何影響。
也就是說，如果僅僅是返回型別不相同，而函式名和引數都完全相同的兩個函式，不能構成過載，編譯器會告知”ambiguous”（二義性）等詞以表達其不滿：
|
1 2 3 4 5 6 7 |
//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宣告，發生隱藏“。
可見有兩種產生隱藏的情況，分別對應不能滿足過載和覆蓋條件的情況。
另外必須要注意的是，在類外討論時，也可能發生隱藏，如在名字空間中，如下述程式碼所示：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#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; } |
輸出結果：
|
1 2 |
global foo() a::foo() |
注意，名字空間a中的foo隱藏了其它作用域（這裡是全域性作用域）中的所有foo名稱，foo(10)不能通過編譯，因為全域性作用域中的int foo(int)版本也已經被a::foo()隱藏了，除非使用::foo(10)顯式進行呼叫。
這也告訴我們，無論何時，都使用完整名稱修飾（作用域解析符呼叫函式，或指標、物件呼叫成員函式）是一種好的程式設計習慣。
好了，上面零零散散說了太多理論的東西，我們需要一段實際的程式碼，來驗證上述所有的結論：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
#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執行結果：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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虛擬函式的地址。
寫到這裡，不知道讀者是否已經明白，這些繞來繞去的關係。在實際程式碼運用中，可能並不會寫出含有這麼多“陷阱”的測試程式碼，我們只要弄清楚過載、覆蓋和隱藏的具體特徵，並頭腦清醒地知道，我現在需要的是哪一種功能（通常也不會需要隱藏），就能寫出清析的程式碼。上面的程式碼其實是一個糟糕的例子，因為在這個例子中，過載、覆蓋、隱藏並存，我們編寫程式碼，就是要儘可能防止這種含混不清的情況發生。
記住一個原則：每一個方法，功能和職責儘可能單一，否則，嘗試將它拆分成為多個方法。