C++ 一篇搞懂繼承的常見特性

• 在定義一個新的類 B 時，如果該類與某個已有的類 A 相似（指的是 B 擁有 A 的全部特點），那么就可以把 A 作為一個基類，而把B作為基類的一個派生類（也稱子類）。
  
  

• 派生類是通過對基類進行修改和擴充得到的，在派生類中，可以擴充新的成員變量和成員函數(shù)。
• 派生類擁有基類的全部成員函數(shù)和成員變量，不論是private、protected、public。需要注意的是：在派生類的各個成員函數(shù)中，不能訪問基類的 private 成員。

|| 02 需要繼承的例子

程序猿種類有很多種，如 C/C++ 程序猿，Java 程序猿，Python 程序猿等等。那么我們要把程序猿設(shè)計成一個基類， 我們則需要抽出其特有的屬性和方法。

所有程序猿的共同屬性（成員變量）：

1. 姓名
2. 性別
3. 職位

所有的程序猿都有的共同方法（成員函數(shù)）：

1. 是否要加班？
2. 是否有獎勵？

而不同的程序猿，又有各自不同的屬性和方法：

• C++ 程序猿：是否是音視頻、網(wǎng)游領(lǐng)域
• Java 程序猿：是否是微服務(wù)領(lǐng)域
• Python 程序猿：是否是人工智能、大數(shù)據(jù)領(lǐng)域

|| 03 派生類的寫法

繼承的格式如下：

class 派生類名：public 基類名{
};

程序猿 Coder 基類：

class Coder{public: bool isWorkOvertime(){} // 是否要加班
 bool isReward(){} // 是否有獎勵
 void Set(const string & name) // 設(shè)置名字 { m_name = name; }
 ...
private: string m_name; // 姓名 string m_post; // 職位 int m_sex; // 性別};

Python 程序猿 PythonCoder 派生類：

class PythonCoder : public Coder{public: bool isAIField(){} // 是否是人工智能領(lǐng)域 bool isBigDataField(){} // 是否是大數(shù)據(jù)領(lǐng)域};

|| 04 派生類對象的內(nèi)存空間

在派生類對象中，包含著基類對象，而且基類對象的存儲位置位于派生類對象新增的成員變量之前，相當于基類對象是頭部。

class CBase{ int a1; int a2;};
class CDerived : public CBase{ int a3; };

派生類對象的大小 = 基類對象成員變量的大小 + 派生類對象自己的成員變量的大小

|| 01 類之間的兩種關(guān)系

繼承的關(guān)系是「是」的關(guān)系：

• 基類 A，B 「是」基類 A 的派生類。

• 邏輯上要求：一個 B 對象也「是」一個 A 對象。

• C 類中「有」成員變量 i，i 成員變量是 D 類的，則 C 和 D 是復(fù)合關(guān)系。

• 邏輯上要求：D 對象是 C 對象的固有屬性或組成部分。

|| 02 繼承關(guān)系的使用

假設(shè)已經(jīng)存在了 Man 類表示男人，后面需要些一個 Women 類來表示女人。Man 類和 Women 類確實是有共同之處，那么就讓 Women 類繼承 Man 類，是否合適？

我們先想想繼承的邏輯要求，假設(shè) Women 類繼承 Man 類后的邏輯就是：一個女人也是一個男人。很明顯，這顯然不成立！

所以，好的做法是概括男人和女人的共同特點，抽象出一個 Human 類表示人，然后 Man 和 Woman 都繼承 Human 類。

|| 03 復(fù)合關(guān)系的使用

假設(shè)要寫一個小區(qū)養(yǎng)狗管理系統(tǒng)：

• 需要寫一個「主人」類。
• 需要些一個「狗」類。

假定狗只有一個主人，但是一個主人可以最多有 10 條狗，應(yīng)該如何設(shè)計和使用「主人」類 和「狗」類呢？我們先看看下面幾個例子。

例子一

• 為主人類設(shè)一個狗類的成員對象數(shù)組；
• 為狗類設(shè)一個主人類的成員對象。

class CDog;class CMaster // 主人類{ CDog dogs[10]; // 狗類的成員對象數(shù)組};
class CDog // 狗類{ CMaster m; // 主人類的成員對象};

例子一可以發(fā)現(xiàn)是：

• 主人類會構(gòu)造 10 個狗對象
• 狗類會構(gòu)造 1 個主人對象

相當于人中有狗，狗中有人：

這樣是不好的，因為會產(chǎn)生循環(huán)不斷的構(gòu)造，主人類構(gòu)造狗對象，狗類又構(gòu)造主人對象....

例子二

• 為狗類設(shè)一個主人類的成員對象；
• 為主人類設(shè)一個狗類的對象指針數(shù)組。

class CDog;class CMaster // 主人類{ CDog * pDogs[10]; // 狗類的對象指針數(shù)組};
class CDog // 狗類{ CMaster m; // 主人類的成員對象};

這樣又變成狗中有人，人去指向「狗中有人」的狗，關(guān)系就會顯得很錯亂，如下圖： 

例子三

• 為狗類設(shè)一個主人類的對象指針；
• 為主人類設(shè)一個狗類的對象數(shù)組。

class CDog;class CMaster // 主人類{ CDog dogs[10]; // 狗類的對象數(shù)組};
class CDog // 狗類{ CMaster * pm; // 主人類的對象指針};

這樣就會變成，人中有狗，人里面的狗又會指向主人，雖然關(guān)系相對好了一點，但是同樣還是會繞暈，效果如下圖：

例子四

• 為狗類設(shè)一個主人類的對象指針；
• 為主人類設(shè)一個狗類的對象指針數(shù)組。
  
  

class CDog;class CMaster // 主人類{ CDog * pDogs[10]; // 狗類的對象指針數(shù)組};
class CDog // 狗類{ CMaster * pm; // 主人類的對象指針};

這個是正確的例子，因為相當于人和主人是獨立的，然后通過指針的作用，使得狗是可以指向一個主人，主人也可以同時指向?qū)儆谧约旱?10 個狗，這樣會更靈活。

|| 04 指針對象和普通對象的區(qū)別

如果不用指針對象，生成 A 對象的同時也會構(gòu)造 B 對象。用指針就不會這樣，效率和內(nèi)存都是有好處的。

比如：

class Car{ Engine engine; // 成員對象 Wing * wing; // 成員指針對象};

定義一輛汽車，所有的汽車都有 engine，但不一定都有 wing 這樣對于沒有 wing 的汽車，wing 只占一個指針，判斷起來也很方便。

• 空間上講，用指針可以節(jié)省空間，免于構(gòu)造 B 對象，而是只在對象中開辟了一個指針，而不是開辟了一個對象 B 的大小。
• 效率上講，使用指針適合復(fù)用。對象 B 不但 A 對象能訪問，其他需要用它的對象也可以使用。
• 指針對象可以使用多態(tài)的特性，基類的指針可以指向派生鏈的任意一個派生類。
• 指針對象，需要用它的時候，才需要去實例化它，但是在不使用的時候，需要手動回收指針對象的資源。

派生類（子類）可以定義一個和基類（父類）成員同名的成員，這叫「覆蓋」。

在派生類（子類）中訪問這類成員時，默認的情況是訪問派生類中定義的成員。要在派生類中訪問由基類定義的同名成員時，要使用作用域符號::

下面看具體的例子：

// 基類class Father{public: int money; void func();};
 // 派生類class Son : public Father // 繼承{public: int money; // 與基類同名成員變量 void func(); // 與基類同名成員函數(shù)
 void myFunc(); };
void Son::myFunc(){ money = 100; // 引用的是派生類的money Father::money = 100; // 引用的是基類的money
 func(); // 引用的是派生類的 Father::func(); // 引用的是基類的}

相當于 Son 對象占用的存儲空間：

我們都知道基類的 public 成員，都是可以被派生類成員訪問的，那么基類的 protected、private 成員，分別可以被派生類成員訪問嗎？

帶著這個問題，我們可以先看下面的栗子：

class Father{public: int nPublic; // 公有成員protected: int nProtected; // 保護成員private: int nPrivate; // 私有成員};
class Son : public Father{ void func(){ nPublic = 1; // OK nProtected = 1; // ok nPrivate =1; // error，不可訪問從基類繼承的private成員
 Son a; a.nProtected = 1; // error,a不是當前對象 }
};
int main(){
 Father f; Son s;
 f.nPublic; // OK s.nPublic; // OK
 f.nProtected; // error s.nProtected; // error
 f.nPrivate; // error s.nPrivate; // error}

基類的 protected、private 成員對于派生類成員的權(quán)限說明:

通常在初始化派生類構(gòu)造函數(shù)時，派生類構(gòu)造函數(shù)是要實現(xiàn)初始化基類構(gòu)造函數(shù)的。那么如何在派生類構(gòu)造函數(shù)里初始化基類構(gòu)造函數(shù)呢？

class Bug {private : int nLegs; int nColor;public: int nType; Bug (int legs, int color); void PrintBug (){ };};
class FlyBug : public Bug // FlyBug 是Bug 的派生類{ int nWings;public: FlyBug( int legs,int color, int wings);};
Bug::Bug( int legs, int color){ nLegs = legs; nColor = color;}
// 錯誤的FlyBug 構(gòu)造函數(shù)FlyBug::FlyBug ( int legs,int color, int wings){ nLegs = legs; // 不能訪問 nColor = color; // 不能訪問 nType = 1; // ok nWings = wings;}
// 正確的FlyBug 構(gòu)造函數(shù)：FlyBug::FlyBug ( int legs, int color, int wings):Bug( legs, color){ nWings = wings;}
int main() { FlyBug fb ( 2,3,4); fb.PrintBug(); fb.nType = 1; fb.nLegs = 2 ; // error. nLegs is private return 0;}

在上面代碼例子中：

• 第24-30行的派生類構(gòu)造函數(shù)初始化基類是錯誤的方式，因為基類的私有成員是無法被派生類訪問的，也就無法初始化。

• 第33-36行代碼是正確派生類構(gòu)造函數(shù)初始化基類構(gòu)造函數(shù)的方式，通過調(diào)用基類構(gòu)造函數(shù)來初始化基類，在執(zhí)行一個派生類的構(gòu)造函數(shù) 之前，總是先執(zhí)行基類的構(gòu)造函數(shù)。

從上面的例子中我們也得知構(gòu)造派生對象前，是先構(gòu)造基類對象，那么在析構(gòu)的時候依然依據(jù)“先構(gòu)造，后初始化”的原則，所以派生類析構(gòu)時，會先執(zhí)行派生類析構(gòu)函數(shù)，再執(zhí)行基類析構(gòu)函數(shù)。

如下栗子：

class Base {public: int n;
 Base(int i) : n(i) { cout << "Base " << n << " constructed" << endl; }
 ~Base() {  cout << "Base " << n << " destructed" << endl;  }};
class Derived : public Base {public: Derived(int i) : Base(i) {  cout << "Derived constructed" << endl;  }
 ~Derived() {  cout << "Derived destructed" << endl; }};
int main() {     Derived Obj(3);  return 0; }

輸出結(jié)果：

Base 3 constructedDerived constructedDerived destructedBase 3 destructed

|| 01 public 繼承

// 基類class Base {};
// 派生類class Derived : public Base {};
Base b; // 基類對象Derived d; // 派生類對象

• 派生類的對象可以賦值給基類對象

b = d;

• 派生類對象可以初始化基類引用

Base & br = d;

• 派生類對象的地址可以賦值給基類指針
  

Base * pb = & d;

注意：如果派生方式是 private 或 protected，則上述三條不可行

|| 02 protected 和 private 繼承

// 基類class Base {};
// 派生類class Derived : protected Base {};
Base b; // 基類對象Derived d; // 派生類對象

• protected 繼承時，基類的 public 成員和 protected 成員成為派生類的 protected 成員；
• private 繼承時，基類的 public 成員成為派生類的 private 成員，基類的 protected 成員成 為派生類的不可訪問成員；
• protected 和 private 繼承不是「是」的關(guān)系。

所以派生方式是 private 或 protected，則是無法像 public 派生承方式一樣把派生類對象賦值、引用、指針給基類對象。

|| 03 基類與派生類的指針強制轉(zhuǎn)換

public 派生方式的情況下，派生類對象的指針可以直接賦值給基類指針：

Base *ptrBase = & objDerived;

• ptrBase 指向的是一個 Derived 派生類（子類）的對象
• *ptrBase 可以看作一個 Base 基類的對象，訪問它的 public 成員直接通過 ptrBase 即可，但不能通過 ptrBase 訪問 objDerived 對象中屬于 Derived 派生類而不屬于基類的成員。

通過強制指針類型轉(zhuǎn)換，可以把 ptrBase 轉(zhuǎn)換成 Derived 類的指針

Base * ptrBase = &objDerived;Derived *ptrDerived = ( Derived * ) ptrBase;

程序員要保證 ptrBase 指向的是一個 Derived 類的對象，否則很容易會出錯。