對于繼承，這是C++中相當重要的語法，
學習此語法可以更好的認知C++這個恢弘的世界，

介紹繼承

C++作為一個面向物件的語言，而面向物件的編程的主要目的之一就是提供可重用的代碼

當開發大型專案時，重用經過測驗的代碼，可是比新撰寫的代碼要可靠好多，

比如，使用經過深海實戰的深潛器可是比用新技術制造的嶄新深潛器要可靠的多（嘻嘻，參考龍族3，凱撒小隊使用迪里雅斯特號進入神葬所）

已有代碼經過多次測驗調整，bug已經極大程度的減少了，對于專案和小組成員的血壓比較友好，

在C++中，有類模板，函式模板，可以重復使用，降低開發者血壓，

而對于C++的類而言，也提供了更高層次的重用，
有類別庫的概念，類別庫是由類宣告和實作構成的，組合了資料表示和類方法，
C++提供了類繼承，來為開發者提供對類的修改和拓展的方法，

類繼承，能夠從已有的類派生出新的類，而派生類繼承了原有類（基類）的特征，包括方法，

正如 繼承一筆財產 遠比自己 白手起家 容易成功，
通過繼承派生出的類遠比自己重新設計一個類容易，
（話糙理不糙）

類繼承舉例

• 某個字串類，可以派生出一個類，添加指定字串顯示顏色的資料型別，
• 在已有的類中添加功能（成員函式）
• 航空公司給普通乘客提供基礎服務可以看作一個類，而給商務艙乘客提供跟高級的服務可以在普通服務類派生出一個商務艙服務類，并添加更多服務方法，

通過對原始類進行修改來滿足開發者的更多需求，而繼承機制只需要提供新特性，且不需要訪問源代碼就能派生出新類，

類繼承的認知

當兩個類中有大量重復的資訊（類成員變數或成員函式），僅存在少量差別時，可以使用類繼承，對類進行復用，

舉例：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Player
{
protected:
	string _name;//名字
	bool hasTable;//是否有比賽場地

};

class Member_Player:public Player
{
protected:
	vector<int> History_Score;//歷史得分
	double Rating;//獲勝比
};
int main(void)
{
	Player Tom;//普通玩家Tom
	Member_Player Jack;//VIP（辦卡）玩家Jack
	return 0;
}

繼承關系和訪問限定符

private/public/protected是C++中的關鍵字，他們描述了對類成員的訪問控制，
描述了對類成員的訪問權限大小，

public > protected >= private，
對于沒有涉及到繼承時，protected與private的權限是一樣的，類外都是不能直接訪問其所修飾的成員，

public是完全開放的的權限，任何成員都能在類外直接被訪問，

而繼承方式，也是靠這三個關鍵字來控制，
列了一張表

這里面，派生類中的public成員、protected成員、private成員的意思，是指，從基類（父類）中繼承的成員，在派生類（子類）中的訪問限定是這些權限，protected和private者兩權限是一樣的，都是不能直接訪問，但是可以通過public的成員函式去訪問，

private訪問與protected訪問的區別

但是，
protected修飾

private修飾

這就說明protected與private在繼承中還是存在一些差別，
我的理解是這樣的，protected訪問限定，在基類中功能和private是一樣的，阻止類外訪問成員，而繼承后，在派生類中，privates是完全阻止在類（基類）外進行訪問，在派生類中通過成員函式去訪問也是不允許的，
也就是說基類中的private成員正在派生類中是完全不可見的，
但是在派生類中是存在的，只是派生類中是完全沒有權限去訪問的，

總結一下：
對基類的外部而言，protected成員與private成員相似；
但對于派生類中，protected成員與基類中的public成員相似，
對于基類中private成員，派生類中在邏輯（語法）上是不可訪問，不可見的，是不存在的；
但從記憶體（物理）的角度來說，基類中的private成員是存在于派生類中，

分析訪問限定與繼承方法的排列組合

總的來說，對于繼承方式與訪問權限都是
公開（public）> 保護（protected）> 私有（private），最后在派生類中，對于基類中的成員，都是權限遵循較小的那個權限，
如果是private繼承，那么基類中的成員在派生類中都是不可見、無法訪問的，無論在基類中的公開還是保護成員（邏輯上），但是在物理上還是依舊在派生類中（參見上），

也就是說，對于派生類繼承基類的成員而言，要經歷繼承方式與訪問限制，而這些都存在一定的權限，所以，大概總結一下，最后派生類中，對于基類的成員的繼承權限（訪問權限），找繼承方式于、與訪問限制中較小的權限，作為派生類繼承來的權限，

public（公有） > protected（保護） > private（私有）

賦值兼容規則

提問：基類與派派生類創建的物件是否可以互相賦值

答：派生類物件可以給基類物件賦值
但，基類物件不能給派生類物件賦值

這就存在一個切割賦值的概念了，

派生類物件給基類物件賦值

基類物件給派生類物件賦值

指標與參考

基類和派生類的指標與參考，
其中這兩者的關系是，

基類指標和參考可以指向派生類的對像，
但是派生類的指標和參考不能指向基類，

為什么

在我學習C語言的時候，認識到一個概念，指標其實就是計算機記憶體中的地址，指標是計算機記憶體中的一個變數空間，變數空間的大小取決于計算機是多少位機，
指標是一個變數空間，該空間儲存的值就是計算機中的某個空間的地址（非法的或合法的），
但是指標并不止步于此，指標還決定了訪問空間的位元組大小，這是取決于指標的型別，也就是說，指標還要考慮能夠在指向空間中訪問的位元組大小，這是非常關鍵的概念，
當基類指標指向派生類物件時，基類指標其實也就只能訪問，派生類中，屬于基類中的成員，對于派生類新增的成員是無法訪問的，

也就說，對于這個指標是合法的，不存在任何訪問問題，

但是對于派生類指標而言，就存在越界訪問的問題（可能，只是我這個水平的理解），
因為，派生類中比基類多了一些成員，對于派生類指標，其訪問位元組大小要比基類指標多，那么就存在一些非法空間可能會被訪問，

所以，C++考慮安全起見，就不會允許可能存在越界的情況（拙見，大佬指正一下），

而對于參考而言，和指標是一樣的，因為，參考就是指標的封裝，底層其實還是指標（匯編角度），

好玩的地方

這樣，基類的建構式或者拷貝建構式中的基類指標或參考也能接收派生類物件，這樣，可以使用派生類物件去初始化一個基類物件，某種意義上，基類物件初始化為一個派生類物件，盡管只是初始化了派生類中基類的部分，

對于賦值，其實是呼叫了隱式賦值運算子多載，

建議

對于C++繼承而言，有三種繼承方式，有三種訪問限制，

根據上面的分析，盡量使用public繼承， 對于基類中的成員變數使用protected限定，

使用private訪問限定，導致派生類中根本不可見基類物件，無意義，使用protected或private訪問控制，會導致，積累詞語無法再類外訪問或不可見，對于派生類繼承后沒什么用，所以不推薦，

繼承中的作用域

類是存在作用域的，基類于派生類是存在繼承關系，但是，這依就是兩個獨立的作用域，

基類與派生類中一樣識別符號的成員

一樣識別符號的成員，包括成員變數與成員函式，
這是允許定義一樣的識別符號的成員，

class Player
{
protected:
	string _name;//名字
	bool hasTable;//是否有比賽場地
public:
	Player(string name="Tom",bool has=true)
		:_name(name)
		,hasTable(has)
	{}
	void Print(void)
	{
		cout << "Player:"<<_name << endl;
	}
};
class Member_Player:public Player
{

public:
	Member_Player(Player aim,vector<int> Score, double rate)
		:Player(aim),History_Score(Score),Rating(rate)
	{}
	void Print(void)
	{
		cout << "Member_Player:"<<Player::_name << endl;
	}
protected:
	vector<int> History_Score;//歷史得分
	double Rating;//獲勝比
};

int main(void)
{
	vector<int> v = { 1,2,3,4,5 };
	Player Tom("Tom",false);
	Member_Player Jack({ "Jack",true }, v, 0.4);
	Player op (Jack);
	Jack.Print();
	Jack.Player::Print();
	return 0;
}

如果是直接呼叫，只能呼叫派生類中的Print函式，
如果想呼叫基類中的Print函式，必須要宣告類域，
還有，如果想在派生類中使用基類中的成員變數（前提是不能為private），直接呼叫即可，如果派生類中沒有和基類中一樣的成員變數，

class Player
{
public:
	string _name;//名字
	bool hasTable;//是否有比賽場地
public:
	Player(string name="Tom",bool has=true)
		:_name(name)
		,hasTable(has)
	{}
	void Print(void)
	{
		cout << "Player:"<<_name << endl;
	}
};
class Member_Player:public Player
{

public:
	Member_Player(Player aim,vector<int> Score, double rate)
		:Player(aim),History_Score(Score),Rating(rate)
	{}
	void Print(void)
	{
		_name = "hello";
		cout << "Member_Player:"<<_name << endl;
	}
protected:
	vector<int> History_Score;//歷史得分
	double Rating;//獲勝比
	string _name;
};

int main(void)
{
	vector<int> v = { 1,2,3,4,5 };
	Player Tom("Tom",false);
	Member_Player Jack({ "Jack",true }, v, 0.4);
	Player* op = &Jack;
	op->_name = "tom";
	Jack.Print();
	Jack.Player::Print();
	return 0;
}

我把派生類改了一下，

在派生類中增加了一個與基類一樣的成員變數，
呼叫后

看看代碼執行了上面，輸出結果是什么，
我呼叫了基類指標去修改派生類中的基類部分的成員變數，
說明，當呼叫派生類中的Print函式時，使用的成員變數默認是派生類中的成員變數，只有顯示呼叫基類中的Print函式時，其中成員變數的使用是其基類自己的，

也就是說，在不同的類域中，遵循“就近原則”，智慧線在自動的類域中先找，如果有就直接使用，如果找不到，就回去更大的域中去尋找，
無論是成員函式還是成員變數，

其實，在基類與派生類中，有一樣的成員是，這兩個一樣的成員構成隱藏關系，而不是多載關系，因為，這是在兩個獨立的域中，多載是要求在一個作用域中，

當存在上面的例子的情況時，派生類的成員會隱藏基類的成員，除非顯式指明作用域，
例：

注意

最好不要在派生類中定義與基類同名的成員，這個雖然可以通過生你們作用域來指定呼叫，但是，人是最大的bug，一旦出錯，還不好查出來問題在哪，

所以，強烈建議不要使用同名的成員

派生類

is-a關系

這個關系代表：派生類物件也是一個基類物件，可以對基類物件執行任何操作，也可以對派生類物件執行，
也代表包含的關系，
例如，一個fruit類，保存水果的重量和熱量，而一個banana類代表一個香蕉的特性，因為香蕉是一個水果中的一種，所以可以從FRUIT類中派生出BANANA類，還可以為BANANA類增加新的特性，這是一種完全包含的關系，
如：

水果可以是早餐，但早餐不一定是水果，不一定是香蕉，早餐和水果就無法構成is-a的關系

派生的建構式

當創建一個派生類的物件時，并不是直接就根據派生類去創建物件，
首先，會創建基類物件，也就是說，在派生類物件在入堆疊幀時，基類物件已經被創建好了（理解成變數入堆疊），

比如有，創建派生類物件時，首先會呼叫，基類的建構式，然后才會呼叫派生類的建構式，

單步除錯可以完整的看到這個程序，

介紹一下，創建派生類物件的整個流程，

1. 要看在派生類的建構式里是否有顯式呼叫基類的建構式，如果沒有就會呼叫基類中的建構式，
2. 把基類物件創建好后，就會去呼叫派生類的建構式，創建派生類物件，

派生的拷貝（復制）建構式

對于派生類的基類而言，這都不是什么問題，賦值兼容規則，可以讓派生類切割去構造一個基類，然后再回呼叫函式里的定義，創建相應的派生類物件，

還有一點，派生類切割創建基類物件時，呼叫的是基類的建構式，這個函式也要處理深拷貝的問題

其中涉及了深淺拷貝的問題，，這里需要自己去重新撰寫函式定義，默認的拷貝建構式并不適合深拷貝，

在下列情況，會呼叫拷貝建構式

1. 將新物件初始化為一個同類物件
2. 按值將物件傳遞給函式
3. 函式回傳物件的值，而不是參考
4. 編輯器生成的臨時物件

派生類的賦值運算子多載

賦值運算子通常用于同類物件之間的賦值，

注：不要將賦值與初始化搞混了

如果陳述句中創建了新的物件，這是初始化；
如果是陳述句修改已有物件的值，這是賦值，

基類

Player& operator=(const Player& tmp)
	{
		_name = tmp._name;
		hasTable = tmp.hasTable;
		return *this;
	}

派生類

	Member_Player& operator=(const Member_Player& tmp)
	{
		History_Score = tmp.History_Score;
		Rating = tmp.Rating;
		_name = tmp._name;
		hasTable = tmp.hasTable;
		return *this;
	}

可能有些書上，回提供轉移建構式和轉移賦值函式，其實，以我目前的水平看來，都是要先進行型別轉換的（構造了一個臨時物件），都是要轉換成同樣的型別，再處理，

解構式

用于處理回收類創建物件而申請的資源，
這其實根本就不需要我們去顯示呼叫，不然，我們使用類干什么？
看看編譯器是怎么處理這些類的

因為，這些都是屬于堆疊這個記憶體空間中，而堆疊的特性是后入先出，在這里也是一樣的，物件創建，就會進入堆疊，為其開辟堆疊幀，
還有一點，我們先前提到的，使用派生類創建一個物件，要先創建一個基類物件，然后才會創建派生類添加的成員，一起構成一個物件，

當然，可能有人想在派生類的析構中先先清理掉其基類物件，呼叫基類的析構，如：

	~Member_Player()
	{
		Player::~Player();
		cout << "~Member_Player()" << endl;
	}

這樣的話，

會呼叫兩次析構，這就非常不符合，我們的設計原理，如果存在new分配空間的物件，在析構中delete兩次，程式就會直接報錯，所以這是不正確的也就是說，我們不應該在派生類的析構中去顯式呼叫基類的析構，

其正確的結構應該是這樣的，物件都是在堆疊中進行處理，

當，程式結束，系統要開始回收資源，對于創建的物件也要開始呼叫解構式，回收資源，物件就要呼叫解構式，出堆疊，這也是要符合堆疊頂特性的，



就這樣依次列印解構式里的資訊，就會出現最后的效果，

類設計

建構式不能被繼承

建構式不同于其他的類方法，因為這個方法，它是負責創建新的物件的，而其他的方法只是被現有的物件呼叫，這是建構式不被繼承的原因之一，

派生類物件繼承基類的方法，就意味著，這個物件已經被創建好了，而物件沒有創建好，派生類物件也就沒法使用

繼承意味著派生類物件可以使用基類物件的方法，然而，在建構式完成作業前，基類物件是不存在的，

解構式

一定要定義顯式解構式來釋放所有的自定義型別（如：new分配記憶體創建的），并完成類物件所需要的特殊的清理作業，對于基類而言，即使不需要，編譯器會自動處理那些成員，也最好提供一個虛解構式，

解構式也是不能被繼承的，在程式結束時，編譯器會先去呼叫派生類的解構式，然后再去呼叫派生類的解構式，

友元函式

友元函式并不是類成員，因此不能被繼承，
友元只是類外可以突破類的訪問權限的普通函式，

靜態成員

靜態成員得治并不在堆疊幀里，其位置是在靜態區中，無論以什么樣的繼承方式，靜態區中只有那為一一個獨一無二的靜態變數，

有關使用基類方法的說明

• 派生類自動使用繼承而來的基類方法，如果派生類沒有重新定義該方法或者定義了一個函式名一摸一樣的函式，
• 派生類的建構式自動呼叫基類的建構式，如果沒有在初始化成員串列中顯示呼叫（賦值）基類建構式，
• 派生類的友元函式可以通過強制型別轉換，將派生類的參考或者指標轉換為基類參考或者指標，然后使用該指標或參考來呼叫基類的友元函式，

菱形繼承

顧名思義，就是繼承方式特別像菱形
大概長這樣

Jack這個人，即是貴賓用戶，又是作業人員，

比如：你在銀行有5個億的存款，銀行會把你認證為VIP用戶，然后你感到整天揮霍，很無聊，想找些事做，然后銀行經理就會給你安排一個保安（bushi）、某個部門的小負責人，這樣你也就是銀行的員工了，
你在銀行就有兩個身份了，既是VIP用戶，又是銀行員工，

但是，這也引發了一個問題，Worker繼承了Player這個類，而Member_Player也繼承了Player，而Player這個類中的成員有_name,個人的名字，那Worker和Member_Player又被Person給繼承了，那么其繼承的兩個類中有一樣的成員，那么當訪問該成員時，訪問到到底是哪個成員呢？

訪問不明確，這就造成了二義性的問題，
而且，有大量一樣的成員，這又會造成資料冗余的問題，

當然，對于二義性的問題，可以通過指定作用域來解決，

比如：
你在銀行的部門里，是副部長的職位，別人都叫你王副部長，
然而，當銀行經理在辦理業務時，稱呼你，是叫你王總，也就是說你會有不同的稱呼

這樣就能正常編譯，還解決了二義性的問題，

但是，C++作為一個高效的語言怎么能容忍資料冗余和二義性的問題？

虛繼承

可以在Person所繼承的兩個基類（Worker和Member_Player）對他們的基類進行虛擬繼承，因為，二義性和資料冗余的問題出在這上面，

使用了虛繼承的代碼

這兩個一樣的成員_name也能一起變化了，實際上這就是一個成員，

我給你們看看在記憶體中怎么處理的

看到了沒？這個_name的地址都是一樣的地址，即使是顯式呼叫了不同類中的_name，但當復制到時候，其變化的位置是沒有改變的，但是值發生了改變，就說明這兩個變數實際上是一個變數，

這樣就將虛繼承中一樣的成員化為一份

這樣，就解決了資料冗余和二義性的問題，

感謝大佬觀看，感謝感謝！