微信公眾號：「小林coding」
用簡潔的方式，分享編程小知識，

繼承和派生

01 繼承和派生的概念

繼承：

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

派生類：

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

02 需要繼承機制的例子

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

所有程式猿的共同屬性（成員變數）：

姓名
性別
職位

所有的程式猿都有的共同方法（成員函式）：

是否要加班？
是否有獎勵？

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

C++ 程式猿：是否是音視頻、網游領域
Java 程式猿：是否是微服務領域
Python 程式猿：是否是人工智能、大資料領域

03 派生類的寫法

繼承的格式如下：

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

程式猿 Coder 基類：

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

Python 程式猿 PythonCoder 派生類：

class PythonCoder : public Coder
{
public:
    bool isAIField(){}      // 是否是人工智能領域
    bool isBigDataField(){} // 是否是大資料領域
};

04 派生類物件的記憶體空間

派生類物件的大小 = 基類物件成員變數的大小 + 派生類物件自己的成員變數的大小，在派生類物件中，包含著基類物件，而且基類物件的存盤位置位于派生類物件新增的成員變數之前，相當于基類物件是頭部，

class CBase
{
    int a1;
    int a2;
};

class CDerived : public CBase
{
    int a3;    
};

繼承關系和復合關系

01 類之間的兩種關系

繼承的關系是「是」的關系：

基類 A，B 「是」基類 A 的派生類，
邏輯上要求：一個 B 物件也「是」一個 A 物件，

繼承的關系是「有」的關系：

C 類中「有」成員變數 i，i 成員變數是 D 類的，則 C 和 D 是復合關系，
邏輯上要求：D 物件是 C 物件的固有屬性或組成部分，

02 繼承關系的使用

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

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

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

03 復合關系的使用

假設要寫一個小區養狗管理系統：

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

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

例子一：

為主人類設一個狗類的成員物件陣列；
為狗類設一個主人類的成員物件，

class CDog;
class CMaster // 主人類
{
    CDog dogs[10]; // 狗類的成員物件陣列
};

class CDog  // 狗類
{
    CMaster m;   // 主人類的成員物件
};

例子一可以發現是：

主人類會構造 10 個狗物件
狗類會構造 1 個主人物件

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

這樣是不好的，因為會產生回圈不斷的構造，主人類構造狗物件，狗類又構造主人物件....

例子二：

為狗類設一個主人類的成員物件；
為主人類設一個狗類的物件指標陣列，

class CDog;
class CMaster // 主人類
{
    CDog * pDogs[10]; // 狗類的物件指標陣列
};

class CDog  // 狗類
{
    CMaster m;   // 主人類的成員物件
};

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

例子三：

為狗類設一個主人類的物件指標；
為主人類設一個狗類的物件陣列，

class CDog;
class CMaster // 主人類
{
    CDog  dogs[10]; // 狗類的物件陣列
};

class CDog  // 狗類
{
    CMaster * pm;   // 主人類的物件指標
};

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

例子四：

為狗類設一個主人類的物件指標；
為主人類設一個狗類的物件指標陣列，

class CDog;
class CMaster // 主人類
{
    CDog  * pDogs[10]; // 狗類的物件指標陣列
};

class CDog  // 狗類
{
    CMaster * pm;   // 主人類的物件指標
};

這個是正確的例子，因為相當于人和主人是獨立的，然后通過指標的作用，使得狗是可以指向一個主人，主人也可以同時指向屬于自己的 10 個狗，這樣會更靈活，

04 指標物件和物件的區別

如果不用指標物件，生成 A 物件的同時也會構造 B 物件，用指標就不會這樣，效率和記憶體都是有好處的，

比如：

class Car
{
    Engine engine; // 成員物件
    Wing * wing;   // 成員指標物件
};

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

空間上講，用指標可以節省空間，免于構造 B 物件，而是只在物件中開辟了一個指標，而不是開辟了一個物件 B 的大小，
效率上講，使用指標適合復用，物件 B 不但 A 物件能訪問，其他需要用它的物件也可以使用，
指標物件可以使用多型的特性，基類的指標可以指向派生鏈的任意一個派生類，
指標物件，需要用它的時候，才需要去實體化它，但是在不使用的時候，需要手動回收指標物件的資源，

派生類覆寫基類成員

01 覆寫

派生類（子類）可以定義一個和基類（父類）成員同名的成員，這叫「覆寫」，在派生類（子類）中訪問這類成員時，默認的情況是訪問派生類中定義的成員，要在派生類中訪問由基類定義的同名成員時，要使用作用域符號::，

下面看具體的例子：

// 基類
class Father
{
public:
    int money;
    void func();
};
 
 // 派生類
class Son : public Father // 繼承
{
public:
    int money;   // 與基類同名成員變數
    void func(); // 與基類同名成員函式
    
    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;  // error
        nPrivate =1;     // ok，訪問從基類繼承的protected成員
        
        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 成員對于派生類成員的權限說明:

基類的 protected 成員	基類的 private 成員
派生類的成員函式可以訪問當前物件的基類的保護成員	不能被派生類成員訪問

派生類的建構式

通常在初始化派生類建構式時，派生類建構式是要實作初始化基類建構式的，那么如何在派生類建構式里初始化基類建構式呢？

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 建構式
FlyBug::FlyBug ( int legs,int color, int wings)
{
    nLegs = legs;   //  不能訪問
    nColor = color; //  不能訪問
    nType = 1;      // ok
    nWings = wings;
}

// 正確的FlyBug 建構式：
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行的派生類建構式初始化基類是錯誤的方式，因為基類的私有成員是無法被派生類訪問的，也就無法初始化，

第33-36行代碼是正確派生類建構式初始化基類建構式的方式，通過呼叫基類建構式來初始化基類，在執行一個派生類的建構式
之前，總是先執行基類的建構式，

從上面的例子中我們也得知構造派生物件前，是先構造基類物件，那么在析構的時候依然依據“先構造，后初始化”的原則，所以派生類析構時，會先執行派生類解構式，再執行基類解構式，

如下栗子：

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; 
}

輸出結果：

Base 3 constructed
Derived constructed
Derived destructed
Base 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 繼承不是「是」的關系，

所以派生方式是 private 或 protected，則是無法像 public 派生承方式一樣把派生類物件賦值、參考、指標給基類物件，

03 基類與派生類的指標強制轉換

public 派生方式的情況下，派生類物件的指標可以直接賦值給基類指標

Base *ptrBase = & objDerived;

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

通過強制指標型別轉換，可以把 ptrBase 轉換成 Derived 類的指標

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

程式員要保證 ptrBase 指向的是一個 Derived 類的物件，否則很容易會出錯，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/75509.html

標籤：C++

上一篇：習題2-6：排列

下一篇：CPP 設計模式學習

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