1 什么是繼承

1.1 繼承的概念

• 繼承機制是面向物件程式設計使代碼可以復用的最重要的手段，這個機制允許程式員在保持原有類特性的基礎上進行擴展，增加功能，這樣產生新的類，稱為派生類，繼承呈現了面向物件程式設計的層次結構，體現了由簡單到復雜的認知程序，以前解除的都是函式復用，繼承是類設計層次的復用，

代碼演示如下

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "peter"; // 姓名
	int _age = 18;
};
class Student : public Person
{
protected:
	int _stuid;
};
int main()
{
	Person p;
	Student s;
	p.Print();
	s.Print();
	return 0;
}

• 繼承后父類的Person的成員（成員函式+成員變數）都會變成子類的一部分，這里體現出了Student復用了Person的成員，下面我們使用監視視窗查看Student物件，可以看到變數的復用，呼叫Print可以看到成員函式的復用，

成員變數的復用
成員函式的復用

1.2 繼承的定義

1.2.1 定義格式

Person是父類，也稱作基類，Student是子類，也稱作派生類，

1.2.2 繼承關系和訪問限定符

1.2.3 繼承基類成員訪問方式的變化

注意（重點）

1. 基類 private 成員在派生類中無論以什么方式繼承都是不可見的，這里的不可見是指基類的私有成員還是被繼承到了派生類物件中，但是語法上限制派生類物件不管在類里面還是類外面都不能去訪問它，
2. 基類 private 成員在派生類中是不能被訪問，如果基類成員不想在類外直接被訪問，但需要在派生類中能訪問，就定義為protected，可以看出保護成員限定符是因繼承才出現的，
3. 實際上面的表格我們進行一下總結會發現：基類的私有成員在子類都是不可見的，基類的其他成員在子類的訪問方式 = Min(成員在基類的訪問限定符，繼承方式)，public > protected > private，
4. 使用關鍵字class時默認的繼承方式是private，使用struct時默認的繼承方式是public，不過最好顯示的寫出繼承方式，
5. 在實際運用中一般使用都是public繼承，幾乎很少使用protetced/private繼承，也不提倡使用protetced/private繼承，因為protetced/private 繼承下來的成員都只能在派生類的類里面使用，實際中擴展維護性不強，

2 基類(父類)物件和派生類(子類)物件之間的賦值轉換

• is a 的關系：一個子類是一個父類，比如，一個學生是一個人
• 派生類物件 可以賦值給 基類的物件 / 基類的指標 / 基類的參考，這里有個形象的說法叫切片或者切割，寓意把派生類中父類那部分切來賦值過去（重點掌握），代碼演示如下，

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

class Person
{
public:
	    // 預設
		string _name = "陳志浩"; // 姓名
		string _sex = "男"; // 性別
		int _age = 25; // 年齡
};
class Student : public Person
{
public:
	int _No = 2019124084; // 學號
};

void Test()
{
	Person pobj;
	Student sobj;
	// 修改子類的成員變數方便演示
	sobj._name = "chenzhiiao";
	sobj._age = 23;
}
int main()
{
	Test();
	return 0;
}

• 基類物件不能賦值給派生類物件

• 指向基類的指標可以指向子類，并且可以強制轉換為子類指標，參考同理也是可以的，這里有點詭異，其實也可以這樣理解：這里指標指向的地址是一樣的，只不過型別限制了可以看哪些部分，所以再強制轉換回子類指標才不會出錯，
  
  
• 上面這些型別轉換都必須是在公有繼承的前提下的，

3 繼承中的作用域

• 在繼承體系中基類和派生類都有獨立的作用域
• 子類和父類中有同名成員，子類成員將屏蔽對父類的同名成員的直接訪問，這種情況叫隱藏，也叫重定義，注意不叫多載也不叫重寫，多載要在同一個作用域才可以，（在子類成員函式中，可以使用 基類::基類成員 顯示訪問）
• 需要注意的是如果是成員函式的隱藏，只需要函式名相同就構成隱藏，即使形參串列和函式體不同也是構成隱藏的哦，
• 注意在實際中在繼承體系里面最好不要定義同名的成員，

來上代碼

#include <iostream>
using namespace std;

class A {
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A {
public:
	void fun(int i)
	{
		cout << "func(int i)->" << i << endl;
	}
};
void Test()
{
	// B中的fun和A中的fun不是構成多載，因為不是在同一作用域
	// B中的fun和A中的fun構成隱藏，成員函式滿足函式名相同就構成隱藏，
	B b;
	b.fun(10);
	b.A::fun();//可以使用 基類::基類成員 顯示訪問
};
int main()
{
	Test();
	return 0;
}

4 派生類(子類)的默認成員函式

派生類的6個默認成員函式，默認就是我們不寫但是會自己生成，那么這4（只關注 構造、拷貝構造、析構、賦值多載）個默認成員函式是如何生成的呢？

• 派生類的建構式必須呼叫基類的建構式初始化基類的那一部分成員，如果基類沒有默認的建構式，則必須在派生類建構式的初始化串列階段顯示呼叫，派生類物件初始化先呼叫基類構造再調派生類構造，，

#include <iostream>
#include <string>
#include <ostream>
using namespace std;
class Person
{
public:
	friend ostream& operator<<(ostream& out, const Person& p);
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person& operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};
ostream& operator<<(ostream& out, const Person& p)
{
	out << "name : " << p._name << endl;
	return out;
}
class Student : public Person{
public:
	friend ostream& operator<<(ostream& out, const Student& s);
	Student(const char* name = "chenzhiao", int no = 2019)
		:Person(name)
		,_no(no)
	{
		cout << "Student()" << endl;
	}
	
	~Student()
	{
		cout << "~Student()" << endl;
	}

protected:
	int _no;
};
ostream& operator<<(ostream& out, const Student& s)
{
	out << "name : " << s._name << ",no : " << s._no << endl;
	return out;
}

void Test()
{
	Student s1;	
	cout << s1;
};
int main()
{
	Test();
	return 0;
}

• 派生類的拷貝建構式必須呼叫基類的拷貝構造完成基類的拷貝初始化，下面代碼中的 Person(s) 有切片行為，

Student(const Student& s)
		: Person(s), _no(s._no)
	{
		cout << "Student(const Student& s)" << endl;
	}

• 派生類的operator=必須要呼叫基類的operator=完成基類的復制，

Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s); 
			//這里必須要用類名指定，否則子類的operator=會把父類的
			//的operator=隱藏掉，導致無限遞回呼叫子類的operator=導致堆疊溢位
			_no = s._no;
		}
		return *this;
	}

• 派生類物件析構清理先呼叫派生類析構再調基類的析構，這里 c++ 的編譯器就保證了先呼叫子類的析構再呼叫父類的析構，
  有兩個迷惑點：1、子類的解構式和父類的解構式構成 隱藏，這是因為多型重寫的需要（下一篇文章我會拉出來再談一下），所有類的解構式，名字會被統一處理成 destructor 2 、 如果自己顯示呼叫，存在父類會析構的問題，不符合先定義后析構的規則

~Student()
	{
		cout << "~Student()" << endl;
		Person::~Person(); 
		//C++的編譯器保證了這個代碼默認會執行，但是必須要放在最后一行才符合規則
		//不能讓程式員去手動指定Person::~Person();必須要放在最后一行
		//萬一程式員不小心放在了第一行，會導致一些不可預料的錯誤，所以不要顯示呼叫
		//這和上面3個默認成員的規則不一樣，需要多注意
	}

• 最后補上一張圖，有助于理解

5 繼承與友元

• 友元關系不能繼承，也即是說：基類友元不能訪問子類私有和保護成員

6 繼承與靜態成員

• 基類定義了 static 靜態成員，則整個繼承體系里面只有一個這樣的成員，無論派生出多少個子類，都只有一個 static 成員實體

來段代碼

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

class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 統計人的個數，
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum; // 學號
};
class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};
void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	Person s5;
	cout << " 人數 :" << Person::_count << endl;
	Student::_count = 0;
	cout << " 人數 :" << Person::_count << endl;
}
int main()
{
	TestPerson();
	return 0;
}

7 復雜的菱形繼承以及菱形虛擬繼承

7.1 單繼承

• 一個子類只有一個直接父類，這種繼承關系叫做單繼承
  

7.2 多繼承

• 一個子類有兩個或者兩個以上的父類叫做多繼承

7.3 菱形繼承

• 菱形繼承是多繼承的一種特殊情況

7.3.1 菱形繼承的問題

• 菱形繼承存在很大的問題，從上面的物件模型圖里可以得出：菱形繼承有資料冗余和資料二義性的問題，在Assistant 的物件里 Person 成員有兩份

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

class Person{
public:
	string _name;
};
class Student : public Person{
protected:
	int _stuId;
};
class Teacher : public Person{
protected:
	int _teaId;
};
class Assistant : public Student, public Teacher{
protected:
	string _majorCourse;
};
void Test()
{

	Assistant a;
	//a._name = "chenzhiao"; 這樣會有二義性無法明確知道訪問的是哪一個

	// 需要顯式指定訪問哪個父類的成員可以解決二義性的問題，但是資料冗余的問題還是無法解決

	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	
}
int main()
{
	Test();
	return 0;
}

7.3.2 如何解決

• 虛擬繼承可以解決菱形繼承的二義性和資料冗余的問題，如上面的繼承關系，在Student和Teacher的繼承，Person時使用虛擬繼承，即可解決問題，需要注意的是，虛擬繼承不要在其他地方去使用，改進上面的代碼，

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

class Person{
public:
	string _name;
};
class Student : virtual public Person{
protected:
	int _stuId;
};
class Teacher : virtual public Person{
protected:
	int _teaId;
};
class Assistant : public Student, public Teacher{
protected:
	string _majorCourse;
};
void Test()
{

	Assistant a;
	a._name = "chenzhiao";
	
}
int main()
{
	Test();
	return 0;
}
// 在菱形繼承的“肩膀處”添加完 virtual 關鍵字，完成虛擬繼承，可以解決資料的二義性和冗余問題，我們來看一下監視視窗

7.3.3 虛擬繼承解決資料冗余和二義性的原理

• 為了研究虛擬繼承原理，我們給出了一個簡化的菱形繼承體系，再借助記憶體視窗觀察物件成員的模型，

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

class A {
public:
	int _a;
};
// class B : public A
class B : public A {
public:
	int _b;
};
// class C : public A
class C : public A {
public:
	int _c;
};
class D : public B, public C {
public:
	int _d;
};

void Test()
{
	D d;
	cout << sizeof(d) << "位元組" << endl;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	
}
int main()
{
	Test();
	return 0;
}

下圖是菱形繼承的記憶體物件成員模型：這里可以看到資料冗余

下圖是菱形虛擬繼承的記憶體物件成員模型

• 可以分析出 D物件中將 A 放在了物件組成的最下面，這個 A 同時屬于 B 和 C，那么 B 和 C 如何找到公共的 A 呢？這里是通過了 B 和 C 的虛基表指標，這兩個指標指向了虛基表，**虛基表存的是當前位置距離 虛基類物件（A）的偏移量，通過偏移量找到A，尤其是發生切片行為的時候，比如 B& b = d，這個偏移量會幫助 b 找到自己的a，完成切片行為，注意：菱形虛擬繼承的效率并不高，因為這一頓操作可想而知，所以盡量不要定義菱形虛擬繼承，這也是 C++ 語法設計的幾個大 bug， **
• 下面是上面的Person關系菱形虛擬繼承的原理解釋：
  

8 繼承的擴展和總結

• 多繼承就是C++語法復雜的體現，有了多繼承就有了菱形繼承，有了菱形繼承就有了菱形虛擬繼承，底層實作就很復雜，所以不建議設計多行程，更不要設計出菱形繼承，否則在復雜度及性能上都有問題，
• 可以認為多繼承就是 C++ 的缺陷之一，很多后來的OO語言都沒有多繼承，如Java，

8.1 繼承和組合

• public繼承是一種is-a的關系，也就是說每個派生類物件都是一個基類物件，比如 狗是一種動物
• 組合是一種has-a的關系，假設B組合了A，每個B物件中都有一個A物件，
• 繼承允許你根據基類的實作來定義派生類的實作，這種通過生成派生類的復用通常被稱為白箱復用，(white-box reuse)，術語“白箱”是相對可視性而言：在繼承方式中，基類的內部細節對子類可見 ，繼承一定程度破壞了基類的封裝，基類的改變，對派生類有很大的影響，派生類和基類間的依賴關系很強，耦合度高，
• 物件組合是類繼承之外的另一種復用選擇，新的更復雜的功能可以通過組裝或組合物件來獲得，物件組合要求被組合的物件具有良好定義的介面，這種復用風格被稱為黑箱復用(black-box reuse)，因為物件的內部細節是不可見的，物件只以“黑箱”的形式出現， 組合類之間沒有很強的依賴關系，耦合度低，優先使用物件組合有助于你保持每個類被封裝，
• 實際盡量多去用組合，組合的耦合度低，代碼維護性好，不過繼承也有用武之地的，有些關系就適合繼承那就用繼承，另外要實作多型，也必須要繼承，類之間的關系可以用繼承，可以用組合，就用組合，