# Item 33: 避免覆蓋（hiding）“通過繼承得到的名字” 作者：Scott Meyers 譯者：fatalerror99 (iTePub's Nirvana) 發布：http://blog.csdn.net/fatalerror99/ 莎士比亞有一個關于名字的說法。"What's in a name?" 他問道，"A rose by any other name would smell as sweet."（語出《羅密歐與朱麗葉》第二幕第二場，朱生豪先生譯為：“姓名本來是沒有意義的；我們叫做玫瑰的這一種花，要是換了個名字，他的香味還是同樣的芬芳。”梁實秋先生譯為：“姓算什么？我們所謂有玫瑰，換個名字，還是一樣的香。”——譯者注）。莎翁也寫過 "he that filches from me my good name ... makes me poor indeed."（語出《奧塞羅》第三幕第三場，朱生豪先生譯為：“可是誰偷去了我的名譽，那么他雖然并不因此而富足，我卻因為失去它而成為赤貧了。”梁實秋先生譯為：“但是他若奪去我的名譽，于他不見有利，對我卻是一件損失哩。”——譯者注）。好吧，在 C++ 中，我們該用哪種態度對待通過繼承得到的名字呢？ 事情的實質與繼承沒什么關系。它與作用域有關。我們都知道它在代碼中是這樣的， ``` int x; // global variable void someFunc() { double x; // local variable std::cin >> x; // read a new value for local x } ``` 讀入 x 的語句指涉 local 變量 x，而不是 global 變量 x，因為內層作用域的名字覆蓋（“遮蔽”）外層作用域的名字。我們可以像這樣形象地表示作用域的狀況：  當編譯器在 someFunc 的作用域中遇到名字 x 時，他們巡視 local 作用域看看是否有什么東西叫這個名字。因為那里有，它們就不再檢查其它作用域。在此例中，someFunc 的 x 類型為 double，而 global x 類型為 int，但這不要緊。C++ 的 name-hiding 規則僅僅是覆蓋那個名字。而相對應的名字的類型是否相同是無關緊要的。在此例中，一個名為 x 的 double 覆蓋了一個名為 x 的 int。 加入 inheritance 以后。我們知道當我們在一個 derived class member function 內指涉位于 base class 內的一件東西（例如，一個 member function，一個 typedef，或者一個 data member）時，編譯器能夠找到我們指涉的東西是因為 derived classes 繼承到聲明于 base classes 中的東西。實際中的運作方法是將 derived class 的作用域嵌套在 base class 作用域之中。例如： ``` class Base { private: int x; public: virtual void mf1() = 0; virtual void mf2(); void mf3(); ... }; class Derived: public Base { public: virtual void mf1(); void mf4(); ... }; ```  本例中包含的既有 public 名字也有 private 名字，既有 data members 也有 member functions。member functions 既有 pure virtual 的，也有 simple (impure) virtual 的，還有 non-virtual 的。那是為了強調我們談論的事情是關于名字的。例子中還可以包括其它類型的名字，例如，enums，nested classes，和 typedefs。在這里的討論中唯一重要的事情是“它們是名字”。與它們是什么東西的名字毫不相關。這個示例中使用了 single inheritance，但是一旦你理解了在 single inheritance 下會發生什么，C++ 在 multiple inheritance 下的行為就很容易預見了。 假設 mf4 在 derived class 中被實現，其中一部分，如下： ``` void Derived::mf4() { ... mf2(); ... } ``` 當編譯器看到這里對名字 mf2 的使用，它就必須斷定它指涉什么。它通過搜索名為 mf2 的某物的定義的作用域來做這件事。首先它在 local 作用域中搜索（也就是 mf4 的作用域），但是它沒有找到被稱為 mf2 的任何東西的聲明。然后它搜索它的包含作用域，也就是 class Derived 的作用域。它依然沒有找到叫做 mf2 的任何東西，所以它上移到它的上一層包含作用域，也就是 base class 的作用域。在那里它找到了名為 mf2 的東西，所以搜索停止。如果在 Base 中沒有 mf2，搜索還會繼續，首先是包含 Base 的 namespace(s)（如果有的話），最后是 global 作用域。 我剛剛描述的過程雖然是正確的，但它還不是一個關于 C++ 中名字如何被找到的完整的描述。無論如何，我們的目的不是為了充分了解關于寫一個編譯器時的名字搜索問題。而是為了充分了解如何避免令人吃驚的意外，而對于這個任務，我們已經有了大量的信息。 再次考慮前面的示例，而且這一次我們 overload mf1 和 mf3，并且為 Derived 增加一個 mf3 的版本。（就像 Item 36 解釋的，Derived 對 mf3 ——一個通過繼承得到的 non-virtual function ——的重載，使得這個設計立即變得可疑，但是出于對 inheritance 之下名字可見性問題的關心，我們就裝作沒看見。） ``` class Base { private: int x; public: virtual void mf1() = 0; virtual void mf1(int); virtual void mf2(); void mf3(); void mf3(double); ... }; class Derived: public Base { public: virtual void mf1(); void mf3(); void mf4(); ... }; ```  以上代碼導致的行為會使每一個第一次遇到它的 C++ 程序員吃驚。基于作用域的名字覆蓋規則（scope-based name hiding rule）不會有什么變化，所以 base class 中的所有名為 mf1 和 mf3 的函數被 derived class 中的名為 mf1 和 mf3 的函數覆蓋。從名字搜索的觀點看，Base::mf1 和 Base::mf3 不再被 Derived 繼承！ ``` Derived d; int x; ... d.mf1(); // fine, calls Derived::mf1 d.mf1(x); // error! Derived::mf1 hides Base::mf1 d.mf2(); // fine, calls Base::mf2 d.mf3(); // fine, calls Derived::mf3 d.mf3(x); // error! Derived::mf3 hides Base::mf3 ``` 就像你看到的，即使 base 和 derived classes 中的函數具有不同的參數類型，它也同樣適用，而且不管函數是 virtual 還是 non-virtual，它也同樣適用。與“在本 Item 的開始處，函數 someFunc 中的 double x 覆蓋了 global 作用域中的 int x”的道理相同，這里 Derived 中的函數 mf3 覆蓋了具有不同類型的名為 mf3 的一個 Base 函數。 這一行為背后的根本原因是為了防止“當你在一個 library 或者 application framework 中創建一個新的 derived class 時，偶然地發生從遙遠的 base classes 繼承 overloads 的情況”。不幸的是，一般情況下你是需要繼承這些 overloads 的。實際上，如果你使用了 public inheritance 而又沒有繼承這些 overloads，你就違反了 Item 32 講解的“base 和 derived classes 之間是 is-a 關系”這一 public inheritance 的基本原則。在這種情況下，你幾乎總是要繞過 C++ 對“通過繼承得到的名字”的缺省的覆蓋機制。 你可以用 using declarations 做到這一點： ``` class Base { private: int x; public: virtual void mf1() = 0; virtual void mf1(int); virtual void mf2(); void mf3(); void mf3(double); ... }; class Derived: public Base { public: using Base::mf1; // make all things in Base named mf1 and mf3 using Base::mf3; // visible (and public) in Derived's scope virtual void mf1(); void mf3(); void mf4(); ... }; ```  現在 inheritance 就可以起到預期的作用： ``` Derived d; int x; ... d.mf1(); // still fine, still calls Derived::mf1 d.mf1(x); // now okay, calls Base::mf1 d.mf2(); // still fine, still calls Base::mf2 d.mf3(); // fine, calls Derived::mf3 d.mf3(x); // now okay, calls Base::mf3 ``` 這意味著如果你從一個帶有重載函數的 base class 繼承，而且你只想重定義或替換它們中的一部分，你需要為每一個你不想覆蓋的名字使用 using declaration。如果你不這樣做，一些你希望繼承下來的名字會被覆蓋。 可以想象在某些時候你不希望從你的 base classes 繼承所有的函數。在 public inheritance 中，這是絕不會發生的，這還是因為，它違反了 public inheritance 在 base 和 derived classes 之間的 is-a 關系。（這就是為什么上面的 using declarations 在 derived class 的 public 部分：在 base class 中是 public 的名字在公有繼承的 derived class 中也應該是 public。）然而，在 private inheritance（參見 Item 39）中，它還是有意義的。例如，假設 Derived 從 Base 私有繼承，而且 Derived 只想繼承沒有參數的那個 mf1 的版本。在這里，using declaration 沒有這個本事，因為一個 using declaration 會使得所有具有給定名字的函數在 derived class 中可見。不，這里是使用了一種不同的技術的情形，即，一個簡單的 forwarding function（轉調函數）： ``` class Base { public: virtual void mf1() = 0; virtual void mf1(int); ... // as before }; class Derived: private Base { public: virtual void mf1() // forwarding function; implicitly { Base::mf1(); } // inline (see Item 30) ... }; ... Derived d; int x; d.mf1(); // fine, calls Derived::mf1 d.mf1(x); // error! Base::mf1() is hidden ``` forwarding function（轉調函數）的另一個功效是用于老式的編譯器，它們（不正確地）不支持用 using declarations 將“通過繼承得到的名字”引入到 derived class 的作用域。 這就是關于 inheritance 和 name hiding 的全部故事，但是當 inheritance 與 templates 結合起來，“通過繼承得到的名字被隱藏”的問題會以一種全然不同的形式呈現出來。關于全部 angle-bracket-demarcated（邊邊角角）的細節，參見 Item 43。 Things to Remember * derived classes 中的名字覆蓋 base classes 中的名字，在 public inheritance 中，這從來不是想要的。 * 為了使隱藏的名字重新可見，使用 using declarations 或者 forwarding functions（轉調函數）。