(public) inheritance 這個表面上簡單易懂的觀念，一旦被近距離審閱，就會被證實是由兩個相互獨立的部分組成的：inheritance of function interfaces（函數接口的繼續）和 inheritance of function implementations（函數實現的繼續）。這兩種 inheritance 之間的差異正好符合本書 IntrodUCtion 中論述的 function declarations（函數聲明）和 function definitions（函數定義）之間的差異?！ ∽鳛橐粋€ class 的設計者，有的時候你想要 derived classes 只繼續一個 member function 的 interface (declaration)。有的時候你想要 derived classes 既繼續 interface（接口）也繼續 implementation（實現），但你要答應它們替換他們繼續到的 implementation。還有的時候你想要 derived classes 繼續一個函數的 interface（接口）和 implementation（實現），而不答應它們替換任何東西。
為了更好地感覺這些選擇之間的不同之處，考慮一個在圖形應用程序中表示幾何圖形的 class hierarchy（類繼續體系）：
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 是一個 abstract class（抽象類），它的 pure virtual function（純虛擬函數）表明了這一點。作為結果，客戶不能創建 Shape class 的實例，只能創建從它繼續的 classes 的實例。但是，Shape 對所有從它（公有）繼續的類施加了非常強大的影響，因為
成員函數 interfaces are always inherited。就像 Item 32 解釋的，public inheritance 意味著 is-a，所以對一個 base class 來說成立的任何東西，對于它的 derived classes 也必須成立。因此，假如一個函數適用于一個 class，它也一定適用于它的 derived classes。
Shape class 中聲明了三個函數。第一個，draw，在一個明確的顯示設備上畫出當前對象。第二個，error，假如 member functions 需要報告一個錯誤，就調用它。第三個，objectID，返回當前對象的唯一整型標識符。每一個函數都用不同的方式聲明：draw 是一個 pure virtual function（純虛擬函數）；error 是一個 simple (impure?) virtual function（簡單虛擬函數）；而 objectID 是一個 non-virtual function（非虛擬函數）。這些不同的聲明暗示了什么呢？
考慮第一個 pure virtual function（純虛擬函數）draw：
class Shape { public: virtual void draw() const = 0; ... }; pure virtual functions（純虛擬函數）的兩個最顯著的特性是它們必須被任何繼續它們的具體類重新聲明，和抽象類中一般沒有它們的定義。把這兩個特性加在一起，你應該熟悉到。
聲明一個 pure virtual function（純虛擬函數）的目的是使 derived classes 繼續一個函數 interface only。
這就使 Shape::draw function 具有了完整的意義，因為它要求所有的 Shape 對象必須能夠畫出來是合情合理的，但是 Shape class 本身不能為這個函數提供一個合乎情理的缺省的實現。例如，畫一個橢圓的算法和畫一個矩形的算法是非常不同的，Shape::draw 的聲明告訴具體 derived classes 的設計者：“你必須提供一個 draw function，但是我對于你如何實現它不發表意見。”
順便提一句，為一個 pure virtual function（純虛擬函數）提供一個定義是有可能的。也就是說，你可以為 Shape::draw 提供一個實現，而 C++ 也不會抱怨什么，但是調用它的唯一方法是用 class name 限定修飾這個調用：
Shape *ps = new Shape; // error! Shape is abstract
Shape *ps1 = new Rectangle; // fine ps1->draw(); // calls Rectangle::draw
Shape *ps2 = new Ellipse; // fine ps2->draw(); // calls Ellipse::draw
class Airplane { public: virtual void fly(const Airport& destination);
...
};
void Airplane::fly(const Airport& destination) { default code for flying an airplane to the given destination }
class ModelA: public Airplane { ... };
class ModelB: public Airplane { ... };
為了表述所有的飛機必須支持一個 fly 函數，并為了“不同機型可能（在理論上）需要不同的對 fly 的實現”的事實，Airplane::fly 被聲明為 virtual。然而，為了避免在 ModelA 和 ModelB classes 中些重復的代碼，缺省的飛行行為由 Airplane::fly 的函數體提供，供 ModelA 和 ModelB 繼續。
這是一個經典的 object-oriented 設計。因為兩個 classes 共享一個通用特性（它們實現 fly 的方法），所以這個通用特性就被轉移到一個 base class 之中，并由兩個 classes 來繼續這個特性。這個設計使得通用特性變得清楚明白，避免了代碼重復，提升了未來的可擴展性，簡化了長期的維護——因為 object-oriented 技術，所有這些東西都受到很高的追捧。XYZ 航空公司應該引以為榮?！ ‖F在，假設 XYZ 公司的財富增長了，決定引進一種新機型，Model C。Model C 在某些方面與 Model A 和 Model B 不同。非凡是，它的飛行不同。
XYZ 公司的程序員在 hierarchy（繼續體系）中增加了 Model C 的 class，但是由于他們匆匆忙忙地讓新的機型投入服務，他們忘記了重定義 fly function：
class ModelC: public Airplane {
... // no fly function is declared }; 于是，在他們的代碼中，就出現了類似這樣的東西：
Airport PDX(...); // PDX is the airport near my home
class ModelC: public Airplane { public: virtual void fly(const Airport& destination);
... };
void ModelC::fly(const Airport& destination) { code for flying a ModelC airplane to the given destination } 這一方案并非十分安全（程序員還是能通過 copy-and-paste 使他們自己陷入麻煩），但是它比最初的設計更加可靠。至于 Airplane::defaultFly，它是 protected（保護的）是因為它完全是 Airplane 和它的 derived classes（派生類）的實現細節。使用飛機的客戶應該只在意它能飛，而不必管飛行是如何實現的。
void Airplane::fly(const Airport& destination) // an implementation of { // a pure virtual function default code for flying an airplane to the given destination }
class ModelA: public Airplane { public: virtual void fly(const Airport& destination) { Airplane::fly(destination); }
...
};
class ModelB: public Airplane { public: virtual void fly(const Airport& destination) { Airplane::fly(destination); }
...
};
class ModelC: public Airplane { public: virtual void fly(const Airport& destination);
...
};
void ModelC::fly(const Airport& destination) { code for flying a ModelC airplane to the given destination } 除了用 pure virtual function（純虛擬函數）Airplane::fly 的函數體代替了獨立函數 Airplane::defaultFly 之外，這是一個和前面的幾乎完全相同的設計。本質上，fly 可以被拆成兩個基本組件。它的 declaration（聲明）指定了它的 interface（接口）（這是 derived classes（派生類）必須使用的），而它的 definition（定義）指定它的缺省行為（這是 derived classes（派生類）可以使用的，但只是在他們明確要求這一點時）。將 fly 和 defaultFly 合并，無論如何，你失去了給予這兩個函數不同的保護層次的能力：原來是 protected 的代碼（通過位于 defaultFly 中實現）現在成為 public（因為它位于 fly 中）。
class Shape { public: int objectID() const; ... }; 當一個 member function（成員函數）是 non-virtual（非虛擬的）時，不應該指望它在 derived classes（派生類）中的行為會有所不同。實際上，一個 non-virtual member function（非虛擬成員函數）指定了一個 invariant over specialization（超越非凡化的不變量），因為不論一個 derived class（派生類）變得多么非凡，它都把它看作是不答應變化的行為。如下所指除的，
聲明一個 non-virtual function（非虛擬函數）的目的是 to have derived classes inherit a function interface as well as a mandatory implementation（使派生類既繼續一個函數的接口，又繼續一個強制的實現）。
對 pure virtual，simple virtual，和 non-virtual functions 的聲明的不同答應你精確指定你需要 derived classes（派生類）繼續什么東西。分別是 interface only（僅有接口），interface and a default implementation（接口和一個缺省的實現），和 interface and a mandatory implementation（接口和一個強制的實現）。因為這些不同的聲明類型意味著根本不同的意義，當你聲明你的 member functions（成員函數）時你必須在它們之間仔細地選擇。假如你這樣做了，你應該可以避免由缺乏經驗的類設計者造成的兩個最常見的錯誤。
第一個錯誤是聲明所有的函數為 non-virtual（非虛擬）。這沒有給 derived classes（派生類）的非凡化留出空間；non-virtual destructors（非虛擬析構函數）尤其有問題（參見 Item 7）。當然，完全有理由設計一個不作為 base class（基類）使用的類。在這種情況下，一套獨享的 non-virtual member functions（非虛擬成員函數）是完全合理的。然而，更通常的情況下，這樣的類既可能出于對 virtual（虛擬）和 non-virtual functions（非虛擬函數）之間區別的無知，也可能是對 virtual functions（虛擬函數）的性能成本毫無根據的擔心的結果。事實是，幾乎任何作為 base class（基類）使用的類都會有 virtual functions（虛擬函數）（還是參見 Item 7）。
另一個常見的錯誤聲明所有的 member functions（成員函數）為 virtual（虛擬）。有時候這樣做是正確的—— Item 31 的 Interface classes（接口類）可以作為證據。然而，它也可能是缺乏表明態度的決心的類設計者的標志。某些函數在 derived classes（派生類）中不應該被重定義，而且只要在這種情況下，你都應該通過將那些函數聲明為 non-virtual（非虛擬）而明確地表達這一點。它不是為那些人服務的，他們假設假如他們只需花一些時間重定義你的所有函數，你的類就會被所有的人用來做所有的事情，假如你有一個 invariant over specialization（超越非凡化的不變量），請直說，不必害怕！
Things to Remember
·Inheritance of interface（接口繼續）與 inheritance of implementation（實現繼續）不同。在 public inheritance（公開繼續）下，derived classes（派生類）總是繼續 base class interfaces（基類接口）。
·Pure virtual functions（純虛擬函數）指定 inheritance of interface only（僅有接口被繼續）。
·Simple (impure) virtual functions（簡單虛擬函數）指定 inheritance of interface（接口繼續）加上 inheritance of a default implementation（缺省實現繼續）。
·Non-virtual functions（非虛擬函數）指定 inheritance of interface（接口繼續）加上 inheritance of a mandatory implementation（強制實現繼續）。
