1.引言

在一些大的項目中，我們可能要重復定義一些類，但是很麻煩，應該怎么辦呢？舉個簡單的例子，我要做一個全校師生統(tǒng)計表，統(tǒng)計學號，教師編號，姓名，年齡，電話，聯(lián)系方式等等，這些內容僅有一點點不同，如果我先定義一個教師類，私有成員包括上述與教師相關的內容，在定義一個學生類，私有成員也包含上述與學生相關的內容，這樣會顯得十分麻煩，而且重復定義，浪費時間。我們不如在這里引入一個新的概念：繼承。通過定義一個基類（也叫父類），其私有成員包括二者共有的內容，之后在分別定義學生和老師類，并繼承基類的私有成員，這樣問題便得以解決！

2.繼承?

在C++中，繼承是一種面向對象編程的核心概念，它允許一個類（稱為派生類或子類）繼承另一個類（稱為基類或父類）的屬性（成員變量）和行為（成員函數(shù)）。通過繼承，派生類可以重用基類的代碼，同時還可以添加新的功能或修改繼承的功能。

2.1?繼承的基本概念

繼承是一種“是一種”（is-a）關系，表示派生類是基類的一種特殊形式。例如，Dog 是 Animal 的一種，Car 是 Vehicle 的一種。通過繼承，派生類可以自動獲得基類的成員變量和成員函數(shù)，并且可以根據(jù)需要對這些成員進行擴展或修改.

2.2 繼承方式

• 公有繼承（public）：

  • 基類的 public 成員在派生類中保持 public。

  • 基類的 protected 成員在派生類中保持 protected。

  • 基類的 private 成員在派生類中不可訪問。

• 保護繼承（protected）：

  • 基類的 public 和 protected 成員在派生類中都變?yōu)?protected。

  • 基類的 private 成員在派生類中不可訪問。

• 私有繼承（private）：

  • 基類的 public 和 protected 成員在派生類中都變?yōu)?private。

  • 基類的 private 成員在派生類中不可訪問。

1. 基類private成員在派?類中?論以什么方式繼承都是不可見的。這里的不可見是指基類的私有成員還是被繼承到了派生類對象中，但是語法上限制派生類對象不管在類里面還是類外面都不能去訪問它。

2. 基類private成員在派?類中是不能被訪問，如果基類成員不想在類外直接被訪問，但需要在派生類中能訪問，就定義為protected。可以看出保護成員限定符是因繼承才出現(xiàn)的。

3. 實際上?的表格我們進行?下總結會發(fā)現(xiàn)，基類的私有成員在派?類都是不可見?；惖钠渌蓡T在派生類的訪問方式 == Min(成員在基類的訪問限定符，繼承方式)，public > protected >private。

4. 使用關鍵字class時默認的繼承方式是private，使?struct時默認的繼承方式是public，不過最好顯?的寫出繼承方式。

5. 在實際運用中?般使用都是public繼承，幾乎很少使用protetced/private繼承，也不提倡使用protetced/private繼承，因為protetced/private繼承下來的成員都只能在派生類的類里面使用，實際中擴展維護性不強。

2.3?繼承的示例

我先將完整的代碼展示出來，隨后做解釋：

#include<iostream>
using namespace std;
class person 
{
public:// 進入校園/圖書館/實驗室刷二維碼等身份認證void identity(){cout << "void identity()" << _name << endl;}
protected:string _name = "zhagsan";string _address;string _tel;int _age = 18;
};
class student :public person
{
public:// 學習void study(){//...identity();}
protected:int _stuid;//學號
};
class teacher :public person
{
public:// 授課void teaching(){//...}
protected:string title; // 職稱
};
int main()
{student s;teacher t;s.identity();t.identity();return 0;
}

運行結果：
?

?解釋：student類和teacher類都繼承了person類，而且都是公有繼承，因此可以調用person類的? ? ? ? ? ? ? ? 函數(shù)?？梢栽囈幌?#xff0c;將public改為protected或者private，程序就會報錯，無法調用基類的? ? ? ? ? ? ? ? identity函數(shù)。

體驗一下protected繼承?

class person
{
public:void print(){cout << _name << endl;cout << _age << endl;}
protected:string _name = "張三"; // 姓名
private:int _age = 18; // 年齡
};
class student :protected person
{
public:void func(){// 不可見//cout << _age << endl;print();}
protected:int _stunum = 1; // 學號
};
int main()
{student s;s.func();         //可以運行//s.print();        //派生類的protected成員，類外不能訪問//s._name;return 0;
}

3. 基類和派生類間的轉換

? public繼承的派生類對象可以賦值給基類的指針 / 基類的引用。這里有個形象的說法叫切片或者切

割。寓意把派?類中基類那部分切出來，基類指針或引用指向的是派?類中切出來的基類那部分。

? 基類對象不能賦值給派生類對象。

class Person
{
protected:string _name = "張三"; // 姓int _id = 1;
};
class student :public Person
{
public:void func(){cout << _id << endl;}
protected:int _stunum = 1; // 學號int _id = 2;
};
int main()
{student s;Person* ptr = &s;Person& ref = s;return 0;
}

4. 繼承中的作用域

4.1 隱藏規(guī)則：

1. 在繼承體系中基類和派生類都有獨立的作用域。

2. 派?類和基類中有同名成員，派?類成員將屏蔽基類對同名成員的直接訪問，這種情況叫隱藏。

（在派生類成員函數(shù)中，可以使用基類::基類成員顯示訪問）

3. 需要注意的是如果是成員函數(shù)的隱藏，只需要函數(shù)名相同就構成隱藏。

4. 注意在實際中在繼承體系??最好不要定義同名的成員

class Person
{
protected:string _name = "張三"; // 姓名int _id = 1;
};
class Student : public Person
{
public:void func(){cout << Person::_id << endl;     //默認的是打印派生類的（自己的）若想打印基類的，要加 // 上“前綴”cout << _id << endl;}
protected:int _stunum = 1; // 學號int _id = 2;
};int main()
{Student s;s.func();return 0;
}

若兩個類的函數(shù)是相同的， 則應該這樣訪問

class A
{
public:void fun(){cout << "func()" << endl;}
};
class B : public A
{
public:void fun(int i){cout << "func(int i)" << i << endl;}
};int main()
{B b;b.fun(10);b.A::fun();return 0;
};

?結果如下：

5. 派生類的默認成員函數(shù)

5.1? 4個常見默認成員函數(shù)

6個默認成員函數(shù)，默認的意思就是指我們不寫，編譯器會變我們?動?成?個，那么在派?類中，這幾個成員函數(shù)是如何?成的呢？

1. 派?類的構造函數(shù)必須調?基類的構造函數(shù)初始化基類的那?部分成員。如果基類沒有默認的構造函數(shù)，則必須在派?類構造函數(shù)的初始化列表階段顯?調?。

2. 派?類的拷?構造函數(shù)必須調?基類的拷?構造完成基類的拷?初始化。

3. 派?類的operator=必須要調?基類的operator=完成基類的復制。需要注意的是派?類operator=隱藏了基類的operator=，所以顯?調?基類的operator=，需要指定基類作?域

4. 派?類的析構函數(shù)會在被調?完成后?動調?基類的析構函數(shù)清理基類成員。因為這樣才能保證派?類對象先清理派?類成員再清理基類成員的順序。

5. 派?類對象初始化先調用基類構造再調派?類構造。

6. 派?類對象析構清理先調?派?類析構再調基類的析構。

7. 因為多態(tài)中?些場景析構函數(shù)需要構成重寫，重寫的條件之?是函數(shù)名相同(這個我們多態(tài)章節(jié)會講解)。那么編譯器會對析構函數(shù)名進?特殊處理，處理成destructor()，所以基類析構函數(shù)不加virtual的情況下，派?類析構函數(shù)和基類析構函數(shù)構成隱藏關系。

class Person
{
public://Person(const char* name = "peter")Person(const char* name): _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; // 姓名
};//子類中父類成員變量當成整體對象，作為子類自定義類型成員看待
class Student : public Person
{
public:// 報錯/*Student(const char* name, int num):_name(name),_num(num){}*/Student(const char* name, int num):Person(name),_num(num){}Student(const Student& s):Person(s),_num(s._num){// 深拷貝 需要自己寫，否則默認生成的就可以夠了//...}Student& operator=(const Student& s){// 深拷貝 需要自己寫，否則默認生成的就可以夠了if (this != &s){Person::operator=(s);_num = s._num;}return *this;}~Student(){// 不需要顯示調用，保證析構時，先子后父//Person::~Person();delete[] _ptr;// 派生類析構結束后，自動調用父類的析構}
protected:int _num = 1; //學號int* _ptr = new int[10];
};

6. 繼承與友元

友元關系不能繼承，也就是說基類友元不能訪問派?類私有和保護成員

class Student;            //前置聲明
class Person
{
public:friend void Display(const Person& p, const Student& s);protected:string _name; // 姓名
};
class Student : public Person
{
public:friend void Display(const Person& p, const Student& s);      //將這行去掉后，編譯器報錯protected:int _stuNum; // 學號
};
void Display(const Person& p, const Student& s)
{cout << p._name << endl;cout << s._stuNum << endl;
}
int main()
{Person p;Student s;// 編譯報錯：error C2248: “Student::_stuNum”: 無法訪問 protected 成員// 解決方案：Display也變成Student 的友元即可Display(p, s);return 0;
}

7. 繼承與靜態(tài)成員

基類定義了static靜態(tài)成員，則整個繼承體系里面只有?個這樣的成員。?論派?出多少個派?類，都只有?個static成員實例。

class Person
{
public:string _name;static int _count;
};int Person::_count = 0;class Student : public Person
{
protected:int _stuNum;
};int main()
{Person p;Student s;cout << &p._name << endl;cout << &s._name << endl;cout << &p._count << endl;cout << &s._count << endl;cout << &Person::_count << endl;cout << &Student::_count << endl;return 0;
}

運行結果：

8. 多繼承及其菱形繼承問題

8.1 繼承模型

單繼承：?個派?類只有?個直接基類時稱這個繼承關系為單繼承

多繼承：?個派?類有兩個或以上直接基類時稱這個繼承關系為多繼承，多繼承對象在內存中的? ? ? ? ? ? ? ? ? 模型是，先繼承的基類在前面，后面繼承的基類在后面，派生類成員在放到最后面。

class Person
{
public:string _name; // 姓名
};class Student : virtual public Person
{
protected:int _num; //學號
};class Teacher : virtual public Person
{
protected:int _id; // 職工編號
};class Assistant : public Student, public Teacher
{
protected:string _majorCourse; // 主修課程
};int main()
{// 編譯報錯：error C2385: 對“_name”的訪問不明確Assistant a;a._name = "peter";// 需要顯示指定訪問哪個基類的成員可以解決二義性問題，但是數(shù)據(jù)冗余問題無法解決a.Student::_name = "xxx";a.Teacher::_name = "yyy";return 0;
}

?9. 繼承和組合

9.1 繼承和組合

? public繼承是?種is-a的關系。也就是說每個派生類對象都是?個基類對象。

? 組合是?種has-a的關系。假設B組合了A，每個B對象中都有?個A對象。

? 繼承允許你根據(jù)基類的實現(xiàn)來定義派?類的實現(xiàn)。這種通過生成派生類的復用通常被稱為白箱復用(white-box reuse)。術語“白箱”是相對可視性而言：在繼承方式中，基類的內部細節(jié)對派生類可見?。繼承?定程度破壞了基類的封裝，基類的改變，對派生類有很?的影響。派生類和基類間的依賴關系很強，耦合度高。

? 對象組合是類繼承之外的另?種復用選擇。新的更復雜的功能可以通過組裝或組合對象來獲得。對象組合要求被組合的對象具有良好定義的接口。這種復用風格被稱為黑箱復用(black-box reuse)，因為對象的內部細節(jié)是不可見的。對象只以“黑箱”的形式出現(xiàn)。 組合類之間沒有很強的依賴關系，耦合度低。優(yōu)先使用對象組合有助于你保持每個類被封裝。

? 優(yōu)先使用組合，而不是繼承。實際盡量多去用組合，組合的耦合度低，代碼維護性好。不過也不太那么絕對，類之間的關系就適合繼承(is-a)那就?繼承，另外要實現(xiàn)多態(tài)，也必須要繼承。類之間的關系既適合?繼承(is-a)也適合組合(has-a)，就用組合。