繼承和派生
01 繼承和派生的概念
繼承：
- 在定義一個新的類 B 時，如果該類與某個已有的類 A 相似（指的是 B 擁有 A 的全部特點），那么就可以把 A 作為一個基類，而把B作為基類的一個派生類（也稱子類）。
派生類：
- 派生類是通過對基類進(jìn)行修改和擴(kuò)充得到的，在派生類中，可以擴(kuò)充新的成員變量和成員函數(shù)。
- 派生類擁有基類的全部成員函數(shù)和成員變量，不論是private、protected、public。需要注意的是：在派生類的各個成員函數(shù)中，不能訪問基類的private成員。
02 需要繼承機(jī)制的例子
程序猿種類有很多種，如 C/C++ 程序猿，Java 程序猿，Python 程序猿等等。那么我們要把程序猿設(shè)計成一個基類， 我們則需要抽出其特有的屬性和方法。
所有程序猿的共同屬性（成員變量）：
- 姓名
- 性別
- 職位
所有的程序猿都有的共同方法（成員函數(shù)）：
- 是否要加班？
- 是否有獎勵？
而不同的程序猿，又有各自不同的屬性和方法：
- 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)存空間
派生類對象的大小 = 基類對象成員變量的大小 + 派生類對象自己的成員變量的大小。在派生類對象中，包含著基類對象，而且基類對象的存儲位置位于派生類對象新增的成員變量之前，相當(dāng)于基類對象是頭部。
class CBase
{
int a1;
int a2;
};
class CDerived : public CBase
{
int a3;
};
繼承關(guān)系和復(fù)合關(guān)系
01 類之間的兩種關(guān)系
繼承的關(guān)系是「是」的關(guān)系：
- 基類 A，B 「是」基類 A 的派生類。
- 邏輯上要求：一個 B 對象也「是」一個 A 對象。
繼承的關(guān)系是「有」的關(guān)系：
- 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 個主人對象
相當(dāng)于人中有狗，狗中有人：
這樣是不好的，因為會產(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; // 主人類的對象指針
};
這個是正確的例子，因為相當(dāng)于人和主人是獨立的，然后通過指針的作用，使得狗是可以指向一個主人，主人也可以同時指向?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)的特性，基類的指針可以指向派生鏈的任意一個派生類。
- 指針對象，需要用它的時候，才需要去實例化它，但是在不使用的時候，需要手動回收指針對象的資源。
派生類覆蓋基類成員
01 覆蓋
派生類（子類）可以定義一個和基類（父類）成員同名的成員，這叫「覆蓋」。在派生類（子類）中訪問這類成員時，默認(rèn)的情況是訪問派生類中定義的成員。要在派生類中訪問由基類定義的同名成員時，要使用作用域符號::。
下面看具體的例子：
// 基類
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(); // 引用的是基類的
}
相當(dāng)于 Son 對象占用的存儲空間：
類的保護(hù)成員
我們都知道基類的 public 成員，都是可以被派生類成員訪問的，那么基類的 protected、private 成員，分別可以被派生類成員訪問嗎？帶著這個問題，我們可以先看下面的栗子：
class Father
{
public:
int nPublic; // 公有成員
protected:
int nProtected; // 保護(hù)成員
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不是當(dāng)前對象
}
};
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)限說明:
| 基類的 protected 成員 | 基類的 private 成員 |
|---|---|
| 派生類的成員函數(shù)可以訪問當(dāng)前對象的基類的保護(hù)成員 | 不能被派生類成員訪問 |
派生類的構(gòu)造函數(shù)
通常在初始化派生類構(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 constructed
Derived constructed
Derived destructed
Base 3 destructed
繼承的賦值兼容規(guī)則
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 基類與派生類的指針強(qiáng)制轉(zhuǎn)換
public 派生方式的情況下，派生類對象的指針可以直接賦值給基類指針
Base *ptrBase = & objDerived;
- ptrBase 指向的是一個 Derived 派生類（子類）的對象
- *ptrBase 可以看作一個 Base 基類的對象，訪問它的 public 成員直接通過 ptrBase 即可，但不能通過 ptrBase 訪問 objDerived 對象中屬于 Derived 派生類而不屬于基類的成員。
通過強(qiáng)制指針類型轉(zhuǎn)換，可以把 ptrBase 轉(zhuǎn)換成 Derived 類的指針
Base * ptrBase = &objDerived;
Derived *ptrDerived = ( Derived * ) ptrBase;
程序員要保證 ptrBase 指向的是一個 Derived 類的對象，否則很容易會出錯。
