Effective C++: 06继承与面向对象设计
32：確定你的public繼承塑模出is-a關系
以C++進行面向對象編程，最重要的一個規則是：public繼承表示的是"is-a"（是一種）的關系。
如果令class D以public形式繼承class B，你便是告訴編譯器說，每一個類型為D的對象同時也是一個類型為B的對象，但是反之不成立。你主張“B對象可派上用場的任何地方，D對象一樣可以派上用場”，因為每一個D對象都是一種B對象。
具體到代碼上，任何函數如果期望獲得一個類型為B（或pointer-to-B或reference-to-B）的實參，都也愿意接受一個D對象（或pointer-to-D或reference-to-D）。
這個論點只對pubiic繼承才成立。private繼承的意義與此完全不同（見條款39），至于protected繼承，那是一種其意義至今仍然困惑我的東西。
?
public繼承和is-a之間的等價關系聽起來頗為簡單，但有時候你的直覺可能會誤導你。舉個例子：class square應該以public形式繼承class Rectangle嗎？每個人都知道正方形是一種矩形，反之則不一定，這是真理，但是看下面的代碼：
class Rectangle { public:virtual void setHeight(int newHeight);virtual void setWidth(int newWidth);virtual int height() const; // return current valuesvirtual int width() const; };void makeBigger(Rectangle& r) // function to increase r's area {int oldHeight = r.height();r.setWidth(r.width() + 10); // add 10 to r's widthassert(r.height() == oldHeight); // assert that r's }顯然，上述的assert結果永遠為真。因為makeBigger只改變r的寬度，r的高度從未被更改。
現在考慮這段代碼，其中使用public繼承，允許正方形被視為一種矩形：
class Square: public Rectangle {...};Square s; assert(s.width() == s.height()); makeBigger(s); assert(s.width() == s.height());很明顯，第二個assert結果也應該永遠為真。因為根據定義，正方形的寬度和其高度相同。但現在我們遇上了一個問題。我們如何調解下面各個assert判斷式：調用makeBigger之前，在makeBigger函數內s的高度和寬度相同；s的寬度改變，但高度不變；makeBigger返回之后，s的高度再度和其寬度相同。
本例的根本困難是，某些可施行于矩形身上的事情卻不可施行于正方形身上。但是public繼承主張，能夠施行于base class對象身上的每件事情，也可以施行于derived class對象身上。在正方形和矩形例子中，那樣的主張無法保持，所以以public繼承塑模它們之間的關系并不正確。
?
?
33：避免遮掩繼承而來的名稱
???????? 1：下面的代碼是一個很簡單的名稱遮掩的例子：
int x;void someFunc() {double x;std::cin >> x; }someFunc的x是double類型而global x是int類型，但那不要緊。C++的名稱遮掩規則所做的唯一事情就是：遮掩名稱。至于名稱是否對應相同的類型，并不重要。本例中一個名為x的double遮掩了一個名為x的int。
?
2：導入繼承之后，當派生類成員函數內引用（refer to）基類內的某物（成員函數、typedef、或成員變量）時，編譯器可以找出我們所refer to的東西，因為派生類繼承了聲明于基類內的所有東西。實際運作方式是，派生類作用域被嵌套在基類作用域內，像這樣：
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(); };void Derived::mf4() {mf2(); }此例內含一組混合了public和private名稱，以及一組成員變量和成員函數名稱。這些成員函數包括pure virtual，impure virtual和non-virtual三種，這是為了強調我們談的是名稱，和其他無關。這個例子也可以加入各種名稱類型，例如~，nested classes和typedef。整個討論中唯一重要的是這些東西的名稱，至于這些東西是什么并不重要。
?
在Derived::mf4函數中，當編譯器看到這里使用名稱mf2，必須估算它refer to什么東西。編譯器首先查找local作用域（也就是mf4覆蓋的作用域），在那兒沒找到任何東西名為mf2。于是查找其外圍作用域，也就是class Derived覆蓋的作用域。還是沒找到任何東西名為mf2，于是再往外圍移動，本例為base class。在那兒編譯器找到一個名為mf2的東西了，于是停止查找。如果Base內還是沒有mf2，查找動作便繼續下去，首先找內含Base的那個namespace(s)的作用域（如果有的話），最后往global作用域找去。
?
再次考慮上面的例子，這次讓我們重載base中的mf1和mf3，并且添加一個新版mf3到Derived去：
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(); };現在，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 classes和derived classes內的函數有不同的參數類型，而且不論函數是virtual或non-virtual，都會發生名稱遮蔽。這和本條款一開始展示的道理相同，如今Derived內的函數mf3遮掩了一個名為mf3但類型不同的base函數。
?
不幸的是你通常會想繼承重載函數。實際上如果你正在使用public繼承而又不繼承那些重載函數，就就違反了base和derived classes之間的is-a關系。可以使用using聲明式達成目標：
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 mf3using Base::mf3; // visible (and public) in Derived's scopevirtual void mf1();void mf3();void mf4(); };現在，繼承機制將一如往昔地運作：
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 classes的所有函數，這是可以理解的。但是在public繼承下，這絕對不可能發生，因為它違反了public繼承所暗示的“base和derived classes之間的is-a關系”。這也就是為什么上述using聲明式被放在derived class的public區域的原因：base class內的public名稱在publicly derived class內也應該是public。
然而在private繼承之下它卻可能是有意義的。假設Derived以private形式繼承Base，而Derived唯一想繼承的mf1是那個無參數版本。using聲明式在這里派不上用場，因為using聲明式會令繼承而來的某給定名稱之所有同名函數在derived class中都可見。我們需要不同的技術，即一個簡單的forwarding函數：
class Base { public:virtual void mf1() = 0;virtual void mf1(int);... // as before };class Derived: private Base { public:virtual void mf1() // forwarding function { Base::mf1(); }... };Derived d; int x;d.mf1(); // fine, calls Derived::mf1 d.mf1(x); // error! Base::mf1() is hidden?
?
34：區分接口繼承和實現繼承
表面上直截了當的public繼承概念，經過更嚴密的檢查之后，發現它由兩部分組成：函數接口繼承和函數實現繼承。身為class設計者，有時候你會希望derived classes只繼承成員函數的接口（也就是聲明）；有時候你又會希望derived classes同時繼承函數的接口和默認實現，但又希望它能夠覆寫（override）它們所繼承的實現；有時候你希望derived classes同時繼承函數的接口和實現，并且不允許覆寫任何東西。
考慮下面的代碼：
class Shape { public:virtual void draw() const = 0;virtual void error(const std::string& msg);int objectID() const; };class Rectangle: public Shape { ... }; class Ellipse: public Shape { ... };Shape類中聲明了三個函數：第一個是純虛函數draw，它使得Shape成為了一個抽象類，所以客戶不能夠創建Shape類的實體，只能創建其derived classes的實體，而且derived classes中必須實現自己的draw函數（否則會報編譯錯誤）；第二個是虛函數error；第三個是普通函數objectID；
?1：聲明一個pure virtual函數的目的是為了讓derived classes只繼承函數接口。
Shape::draw函數是個純虛函數，因為所有Shape對象都應該是可繪出的，但Shape class無法為此函數提供合理的缺省實現，畢竟橢圓形繪法迥異于矩形繪法。Shape::draw的聲明乃是對具象derived classes設計者說，“你必須提供一個draw函數，但我不干涉你怎么實現它。”
在C++中，可以為pure virtual函數提供定義。也就是說你可以為Shape::draw供應一份實現代碼。
?
2：聲明（非純）虛函數的目的，是讓derived classes繼承該函數的接口和缺省實現。
Shape::error函數是個虛函數，它表示每個class都必須支持一個“當遇上錯誤時可調用”的函數，但每個class可自由處理錯誤。如果某個class不想針對錯誤做出任何特殊行為，它可以退回到Shape class提供的缺省錯誤處理行為。也就是說Shape::error的聲明式告訴derived classes的設計者，“你必須支持一個error函數，但如果你不想自己寫一個，可以使用Shape class提供的缺省版本”。
?
3：聲明普通非虛函數的目的是為了令derived classes繼承函數的接口及一份強制實現。
如果成員函數是個非虛函數，意味是它并不打算在derived classes中有不同的行為。實際上一個非虛成員函數所表現的不變性(invariant)凌駕其特異性(specialization )，因為它表示不論derived class變得多么特異化，它的行為都不可以改變，所以它絕不該在derived class中被重新定義。
Shape::objectID函數是個非虛函數，它的聲明表示：“每個Shape對象都有一個用來產生對象識別碼的函數；此識別碼總是采用相同計算方法，該方法由Shape::objectID的定義式決定，任何derived class都不應該嘗試改變其行為”。
?
?
35：考慮virtual函數以外的選擇
???????? 下面的代碼中，GameCharacter表示游戲中的人物角色，成員函數healthValue表示人物的健康程度：
class GameCharacter { public:virtual int healthValue() const;... };???????? 由于不同的人物可能以不同的方式計算他們的健康指數，因此將healthValue聲明為virtual似乎是再明白不過的做法，該函數并未被聲明為pure virtual，這暗示我們將會有個計算健康指數的缺省算法。
?
???????? 下面是幾種不使用virtual的替代方法：
???????? 1：由Non-Virtual interface手法實現Template Method模式
???????? 該方法主張virtual函數應該幾乎總是private。這個流派的擁護者建議，較好的設計是保留healthVaiue為public成員函數，但讓它成為non-virtual，并調用一個private virtual函數進行實際工作：
class GameCharacter { public:int healthValue() const { printf("begin of healthValue\n");int retVal = doHealthValue(); printf("end of healthValue\n");return retVal;} private:virtual int doHealthValue() const {printf("this is GameCharacter::doHealthValue\n");} };class GCA : public GameCharacter { private:virtual int doHealthValue() const {printf("this is GCA::doHealthValue\n");} };int main() {GameCharacter gc;GCA gca;gc.healthValue();gca.healthValue();GameCharacter *pgc1 = new GameCharacter;GameCharacter *pgc2 = new GCA;pgc1->healthValue();pgc2->healthValue();delete pgc1;delete pgc2; }?這種方法，也就是“令客戶通過public non-virtual成員函數間接調用private virtual函數”，稱為non-virtual interface(NVI)手法。它是所謂Template Method設計模式（與C++ templates并無關聯）的一個獨特表現形式。
NVI手法的一個優點隱身在“做一些事前工作”和“做一些事后工作”之中。也就是確保得以在一個virtual函數被調用之前設定好適當場景，并在調用結束之后清理場景。上述代碼的結果如下：
begin of healthValue this is GameCharacter::doHealthValue end of healthValue begin of healthValue this is GCA::doHealthValue end of healthValue begin of healthValue this is GameCharacter::doHealthValue end of healthValue begin of healthValue this is GCA::doHealthValue end of healthValue?
?2：由Function Pointers實現Strategy模式
另一個更戲劇性的設計主張“人物健康指數的計算與人物類型無關”，這樣的計算完全不需要“人物”這個成分。例如我們可能會要求每個人物的構造函數接受一個指針，指向一個健康計算函數，而我們可以調用該函數進行實際計算：
class GameCharacter; // forward declaration// function for the default health calculation algorithm int defaultHealthCalc(const GameCharacter& gc);class GameCharacter { public:typedef int (*HealthCalcFunc)(const GameCharacter&);explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc): healthFunc(hcf){}int healthValue() const{ return healthFunc(*this); }private:HealthCalcFunc healthFunc; };這個做法是常見的Strategy設計模式的簡單應用。使用這種方法，同一人物類型之不同實體可以有不同的健康計算函數，而且某已知人物之健康指數計算函數可在運行期變更。例如GameCharacter可提供一個成員函數setHealthCalculator，用來替換當前的健康指數計算函數。
?
3：由std::function完成Strategy模式
基于函數指針的做法有些苛刻而死板：為什么要求“健康指數之計算”必須是個函數，而不能是某種“像函數的東西”呢？如果一定得是函數，為什么不能夠是個成員函數?為什么一定得返回int而不是任何可被轉換為int的類型呢?
可以改用一個類型為std::function的對象，這些約束就全都不見了。這樣的對象可持有任何可調用物，比如函數指針、函數對象、或成員函數指針等：
class GameCharacter; int defaultHealthCalc(const GameCharacter& gc); class GameCharacter { public:// HealthCalcFunc is any callable entity that can be called with// anything compatible with a GameCharacter and that returns anything// compatible with an int; see below for detailstypedef std::function<int (const GameCharacter&)> HealthCalcFunc;explicit GameCharacter(HealthCalcFunc hcf = defaultHealthCalc): healthFunc(hcf){}int healthValue() const{ return healthFunc(*this); }private:HealthCalcFunc healthFunc; };???????? HealthCalcFunc是一種std::function類型，這種類型的對象可以持有任何與其簽名函數兼容的可調用物。其簽名函數“接受一個reference指向const GameCharacter，并返回int"。所謂兼容，意思是這個可調用物的參數可被隱式轉換為const GameCharacter&，而其返回類型可被隱式轉換為int：
short calcHealth(const GameCharacter&); //返回short而非intstruct HealthCalculator { //函數對象int operator()(const GameCharacter&) const { ... } };class GameLevel { public:float health(const GameCharacter&) const; //成員函數，返回float ... }; class EvilBadGuy: public GameCharacter { ... }; class EyeCandyCharacter: public GameCharacter { ... }; EvilBadGuy ebg1(calcHealth); //使用函數 EyeCandyCharacter ecc1(HealthCalculator()); //使用函數對象 GameLevel currentLevel; //使用成員函數 EvilBadGuy ebg2(std::bind(&GameLevel::health, currentLevel, _1) );?
?? ? ? ? ?4：傳統的Strategy模式
???????? 傳統的Strategy做法會將健康計算函數做成一個分離的繼承體系中的virtual成員函數。設計結果看起來像這樣：
?
???????? 這張圖表示GameCharacter是某個繼承體系的根類，體系中的EvilBadGuy和EyeCandyCharacter都是derived classes；HealthCalcFunc是另一個繼承體系的根類，體系中的S1owHealthLoser和FastHealthLoser都是derived classes，每一個GameCharacter對象都內含一個指針，指向一個來自HealthCalcF}nc繼承體系的對象。具體的代碼如下：
class GameCharacter; class HealthCalcFunc { public:virtual int calc(const GameCharacter& gc) const{ ... }... };HealthCalcFunc defaultHealthCalc;class GameCharacter { public:explicit GameCharacter(HealthCalcFunc *phcf = &defaultHealthCalc): pHealthCalc(phcf){}int healthValue() const{ return pHealthCalc->calc(*this);}private:HealthCalcFunc *pHealthCalc; };?
?
36：絕不重新定義繼承而來的non-virtual函數
之前的條款說過，所謂public繼承意味is-a的關系；在class內聲明一個non-virtual函數會為該class建立起一個不變性，凌駕其特異性。如果將這兩個觀點施行于兩個classes：B(ase)和D(erived)以及non-virtual成員函數B::mf身上，意味著：適用于B對象的每一件事，也適用于D對象；B的derived classes一定會繼承mf的接口和實現，因為mf是B的一個non-virtual函數。
如果D重新定義mf，這樣便出現矛盾：如果D真有必要實現出與B不同的mf，那么“每個D都是一個B”就不為真。既然如此D就不該以public形式繼承B。另一方面，如果D真的必須以public方式繼承B，并且如果D真有需要實現出與B不同的mf，那么mf就無法為B反映出“不變性凌駕特異性”的性質。既然這樣mf應該聲明為virtual函數。最后，如果每個D真的是一個B，并且如果mf真的為B反映出“不變性凌駕特異性”的性質，那么D便不需要重新定義mf，而且它也不應該嘗試這樣做。
??? 因此：任何情況下都不該重新定義一個繼承而來的non-virtual函數。
?
?
37：絕不重新定義繼承而來的缺省參數值
virtual函數系動態綁定，而缺省參數值卻是靜態綁定。
為什么C++堅持以這種乖張的方式來運作呢？答案在于運行期效率。如果缺省參數值是動態綁定，編譯器就必須有某種辦法在運行期為virtual函數決定適當的參數缺省值。這比目前實行的“在編譯期決定”的機制更慢而且更復雜。為了程序的執行速度和編譯器實現上的簡易度，C++做了這樣的取舍。
?
?
38：通過復合塑模出has-a或“根據某物實現出”(is-implemented-in-terms-of)
復合（composition）是類型之間的一種關系，當某種類型的對象內含它種類型的對象，便是這種關系。例如：
class Address { ... }; class PhoneNumber { ... };class Person { public:... private:std::string name; // composed objectAddress address; // dittoPhoneNumber voiceNumber; // dittoPhoneNumber faxNumber; // ditto };上面的代碼中，Person對象由string，Address，PhoneNumber構成。
?1：復合有兩個意義：has-a（有一個），或這是is-implemented-in-terms-of（根據某物實現出）。
因為你正打算在你的軟件中處理兩個不同的領域。如果程序中的對象相當于世界中的某些事物，例如人、汽車、一張張視頻畫面等等。這樣的對象屬于應用域部分。其他對象則純粹是實現細節上的人工制品，像是緩沖區、互斥鎖、查找樹等等。這些對象相當于軟件的實現域。
當復合發生于應用域內的對象之間，表現出has-a的關系；當它發生于實現域內則是表現is-implemented-in-terms-of的關系。
?
2：has-a的關系很好區分，比較麻煩的是區分is-a和is-implemented-in-terms-of這兩種對象關系。
比如：某些情況下必須自己實現一個sets而不能使用標準庫提供的版本。實現sets的方法很多，其中一種便是在底層采用標準庫的linked lists。
首先想到讓set<T>繼承list<T>：
template<typename T> // the wrong way to use list for Set class Set: public std::list<T> { ... };這是錯誤的，因為public繼承意味著is-a的關系，如果D是一種B，對B為真的每一件事情對D也都應該為真。但list可以內含重復元素，但是set的定義卻不允許包含重復元素。因此“Set是一種list”并不為真。
正確的做法是，Set對象可根據一個list對象實現出來：
template<class T> // the right way to use list for Set class Set { public: bool member(const T& item) const;void insert(const T& item);... private:std::list<T> rep; // representation for Set data }; template<typename T> bool Set<T>::member(const T& item) const {return std::find(rep.begin(), rep.end(), item) != rep.end(); }template<typename T> void Set<T>::insert(const T& item) {if (!member(item)) rep.push_back(item); }?
?
39：明智而審慎地使用private繼承
???????? 1：如果classes之間的繼承關系是private，編譯器不會自動將一個derived class對象轉換為一個base class對象：
class Person { ... }; class Student: private Person { ... }; // inheritance is now privatevoid eat(const Person& p); // anyone can eat Person p; // p is a Person Student s; // s is a Student eat(s); // error! a Student isn't a Person???????? 上面針對s的eat調用將會報錯，當eat的形參是Person或Person*時也一樣，都會報錯：error: ‘Person’ is an inaccessible base of ‘Student’。
由private base class繼承而來的所有成員，在derived class中都會變成private屬性，縱使它們在base class中原本是protected或public屬性。
?
?? ? ? ? ?2：Private繼承意味著implemented-in-terms-of（根據某物實現出）。如果讓class D以private形式繼承class B，你的用意是為了采用class B內已經具備的某些特性，不是因為B對象和D對象存在有任何觀念上的關系。因此，private繼承純粹只是一種實現技術，如果D以private形式繼承B，意思是D對象根據B對象實現而得，再沒有其他意涵了。
?
???????? 3：Private繼承意味is-implemented-in-terms-of，之前的條款指出復合的意義也是這樣。如何在兩者之間取舍？答案很簡單：盡可能使用復合，必要時才使用private繼承。何時才是必要？主要是當protected成員和/或virtual函數牽扯進來的時候。
????????
???????? 4：為了能夠知道Widget成員函數的調用頻率，需要記錄每個成員函數的調用次數，然后周期性的審查這些信息。為了完整這個工作，需要設定一個定時器，周期性的取出Widget的狀態。
? ? ? ? ?假設當前有一個定時器類：
class Timer { public:virtual void onTick() const; // automatically called for each tick ... };???????? onTick函數會周期性的執行。因此，可以重新定義那個onTick函數，讓其取出Widget當前狀態。
為了讓Widget重新定義Timer內的virtual函數，Widget必須繼承自Timer。但public繼承在此例并不適當，因為Widget顯然并不是個Timer。這種情況下，必須以private形式繼承Timer：
class Widget: private Timer { private:virtual void onTick() const; // 查看Widget的數據等等.. ... };????????藉由private繼承，Timer的public OnTick在Widget內變成private了。
?
5：上面的方法不是唯一實現目的的方法，其實可以使用復合：
class Widget { private:class WidgetTimer: public Timer {public:virtual void onTick() const;...};WidgetTimer timer; };?使用復合要比使用private繼承有更多的優勢：首先，你或許會想設計Widget使它得以擁有derived classes，但同時你可能會想阻止derived classes重新定義onTick。如果Widget繼承自Timer，上面的想法就不可能實現，即使是private繼承也不可能。但如果WidgetTimer是Widget內部的一個private成員并繼承Timer，Widget的derived classes將無法取用WidgetTimer，因此無法繼承它或重新定義它的virtual函數。
?
6：private繼承主要用于“當一個意欲成為derived class者想訪問base class的protected成分，或為了重新定義一或多個virtual函數”，但這時候兩個classes之間的概念關系其實是is-implemented-in-terms-of而非is-a。
當你面對并不存在is-a關系的兩個classes，其中一個需要訪問另一個的protected成員，或需要重新定義其一或多個virtual函數，private繼承極有可能成為正統設計策略。
?
7：private繼承還適用于一種比較激進的情況：如果一個類不帶任何數據，也就是它沒有non-static成員變量，沒有virtual函數（因為這種函數會為每個對象帶來一個vptr），也沒有virtual base classes（這樣的base classes也會導致體積的額外開銷）。這種類的對象不使用任何空間，因為沒有隸屬于對象的數據需要存儲。但是C++規定，凡是獨立（非附屬）的對象必須有非0大小，所以：
class Empty { public:fun() {printf("this is fun");} private:fun2() {printf("this is fun2");} }; class HoldsAnInt { private:int x;Empty e; };??上面的類定義，sizeof(HoldsAnInt)會大于sizeof(int)，測試結果是sizeof(Empty)為1， sizeof(int)為4，而sizeof(HoldsAnInt)為8。因為面對大小為0的獨立非附屬對象，C++要求默默插入一個char到空對象中，然而因為內存對其的需求，所以sizeof(HoldsAnInt)為8。
?上面的情況適用于獨立非附屬對象，但是不適用于derived class內的base class成分，因為它不是獨立非附屬的，因此：
class HoldsAnInt: private Empty { private:int x; };這樣的定義，sizeof(HoldsAnInt)等于sizeof(int)，這就是所謂的EBO(empty base optimization；空白基類最優化)，EBO一般只在單一繼承可行。
注意，上面的空類不是真的empty，它可以包含typedefs, enums, static成員變量或non-virtual函數。
?
?
40：明智而審慎地使用多重繼承
?1：多重繼承情況下，派生類可能從多個base class繼承相同的名稱，從而導致歧義：
class BorrowableItem { public:void checkOut(); };class ElectronicGadget { private:bool checkOut(int a) const; };class MP3Player: public BorrowableItem, public ElectronicGadget { }; MP3Player mp; mp.checkOut(); // ambiguous! which checkOut??上面的代碼對checkOut的調用會報錯：” reference to ‘checkOut’ is ambiguous”，及時兩個候選函數的訪問權限不同，參數也不相同。為了解決歧義，必須明確指出要調用哪一個base class內的函數：mp.BorrowableItem::checkOut()
?
???????? 2：多重繼承的情況下，有可能形成“鉆石型多重繼承”的情況。為了避免某個數據發生多份拷貝的情況，必須使那些帶有此數據的class成為一個virtual base class：
class File { ... }; class InputFile: virtual public File { ... }; class OutputFile: virtual public File { ... }; class IOFile: public InputFile,public OutputFile { ... };???????? 這種方法的缺點是：使用virtual繼承的那些classes所產生的對象往往比使用non-virtual繼承的兄弟們體積大，訪問virtual base classes的成員變量時，也比訪問non-virtual base classes的成員變量速度慢。種種細節因編譯器不同而異，但基本重點很清楚：你得為virtual繼承付出代價。
另外，virtual base的初始化責任是由繼承體系中的最低層(most derived) class負責，這表示：(1)classes若派生自virtual bases而需要初始化，必須認知其virtual bases--不論那些bases距離多遠；(2)當一個新的derived class加入繼承體系中，它必須承擔其virtual bases(不論直接或間接)的初始化責任。
我對virtual base classes（亦相當于對virtual繼承）的忠告很簡單。第一，非必要不使用virtual bases。平常請使用non-virtual繼承。第二，如果你必須使用virtual base classes，盡可能避免在其中放置數據。這么一來你就不需擔心這些classes身上的初始化（和賦值）所帶來的詭異事情了。
?
下面是一種多重繼承的合理應用場景：
class IPerson { public:virtual ~IPerson();virtual std::string name() const = 0;virtual std::string birthDate() const = 0; };IPerson是個Interface class，CPerson是要繼承該類并需要提供繼承自IPerson的pure virtual函數的實現代碼。現在有個現成的類PersonInfo，它可以完成CPerson所需要的實際工作：
class PersonInfo { public:explicit PersonInfo(DatabaseID pid);virtual ~PersonInfo();virtual const char * theName() const;virtual const char * theBirthDate() const;private:virtual const char * valueDelimOpen() const; // seevirtual const char * valueDelimClose() const; // below };PersonInfo用于以各種格式打印數據庫字段，每個字段值的起始字符和終止字符由valueDelimOpen和valueDelimClose返回，默認的實現分別是’[’ 和 ’]’，但是這兩個界限符號并非人人喜歡，因此valueDelimOpen和valueDelimClose是virtual函數，允許派生類設置自己的界限符號。所以，PersonInfo::theName的實現可能如下：
const char * PersonInfo::valueDelimOpen() const {return "["; // default opening delimiter }const char * PersonInfo::valueDelimClose() const {return "]"; // default closing delimiter }const char * PersonInfo::theName() const {static char value[Max_Formatted_Field_Value_Length];// write opening delimiter std::strcpy(value, valueDelimOpen());//append to the string in value this object's name field (being careful//to avoid buffer overruns!)// write closing delimiter std::strcat(value, valueDelimClose());return value; }作為CPerson的實現者，發現可以使用PersonInfo實現name和birthDate，但是需要界限符號為空。因此，CPerson和PersonInfo的關系是is-implemented-in-terms-of，我們知道這種關系可以有兩種技術實現：復合和private繼承。條款39指出復合通常是較受歡迎的做法，但如果需要重新定義virtual函數，那么繼承是必要的。本例之中CPerson需要重新定義valueDelimOpen和valueDelimClose，所以單純的復合無法應付。最直接的解法就是令CPerson以private形式繼承PersonInfo。
CPerson也必須實現IPerson接口，因此需要以public繼承IPerson。因此這就是多重繼承的一個通情達理的應用：
class CPerson: public IPerson, private PersonInfo { // note use of MI public:explicit CPerson( DatabaseID pid): PersonInfo(pid) {}virtual std::string name() const { return PersonInfo::theName(); } virtual std::string birthDate() const { return PersonInfo::theBirthDate(); } private: const char * valueDelimOpen() const { return ""; } const char * valueDelimClose() const { return ""; } };最后，需要注意的是，如果某種需求下，你唯一能夠提出的設計方案涉及多重繼承，你應該更努力想一想--幾乎可以說一定會有某些方案讓單一繼承行得通。然而多重繼承有時候的確是完成任務之最簡潔、最易維護、最合理的做法，果真如此就別害怕使用它。只要確定，你的確是在明智而審慎的情況下使用它。
?
轉載于:https://www.cnblogs.com/gqtcgq/p/7849533.html
創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎總結
以上是生活随笔為你收集整理的Effective C++: 06继承与面向对象设计的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Appium——api常用函数
- 下一篇： dump java崩溃自动 不生成_基于