繼承的概念

繼承(inheritance)機制是面向對象程序設計使代碼可以復用的最重要的手段，它允許程序員在保持原有類特性的基礎上進行擴展，增加功能，這樣產生新的類，稱派生類。繼承呈現了面向對象程序設計的層次結構，體現了由簡單到復雜的認知過程。以前我們接觸的復用都是函數復用，繼承是類設計層次的復用。

class Person { public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;} protected:string _name = "peter"; // 姓名int _age = 18; // 年齡 }; // 繼承后父類的Person的成員（成員函數+成員變量）都會變成子類的一部分。這里體現出了Student和 //Teacher復用了Person的成員。下面我們使用監視窗口查看Student和Teacher對象，可以看到變量的復用。調用 //Print可以看到成員函數的復用。 class Student : public Person { protected:int _stuid; // 學號 }; class Teacher : public Person { protected:int _jobid; // 工號 }; int main() {Student s;Teacher t;s.Print();t.Print();return 0; }

繼承的方式

由上圖可以看出，Person是基類也是父類，Student是派生類也叫子類。

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

類成員/繼承方式public繼承protected繼承private繼承

基類的public成員	派生類的public成員	派生類的protected成員	派生類的private成員
基類的protected成員	派生類的protected成員	派生類的protected成員	派生類的private成員
基類的private成員	在派生類中不可見	在派生類中不可見	在派生類中不可見

總結

總結：

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

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

實際上面的表格我們進行一下總結會發現，基類的私有成員在子類都是不可見。基類的其他成員在子類的訪問方式 == 成員在基類的訪問限定符，繼承方式中最小的權限，public > protected > private。

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

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

基類和派生類對象賦值轉換

• 派生類對象 可以賦值給 基類的對象 / 基類的指針 / 基類的引用。
• 基類對象不能賦值給派生類對象
• 基類的指針可以通過強制類型轉換賦值給派生類的指針。但是必須是基類的指針是指向派生類對象時才是安全的。這里基類如果是多態類型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 來進行識別后進行安全轉換。
• 可以讓基類的指針或者引用直接引用子類的對象，不能直接使用子類的指針或引用去指向基類對象，必須要強制類型轉換。
  

class Person { protected:string _name; // 姓名string _sex; // 性別int _age; // 年齡 }; class Student : public Person { public:int _No; // 學號 }; void Test() {Student sobj;// 1.子類對象可以賦值給父類對象/指針/引用Person pobj = sobj;Person* pp = &sobj;Person& rp = sobj;//2.基類對象不能賦值給派生類對象//sobj = pobj;// 3.基類的指針可以通過強制類型轉換賦值給派生類的指針pp = &sobj;Student* ps1 = (Student*)pp; // 這種情況轉換時可以的。ps1->_No = 10;pp = &pobj;Student* ps2 = (Student*)pp; // 這種情況轉換時雖然可以，但是會存在越界訪問的問題ps2->_No = 10; }

繼承中的作用域

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

子類和父類中有同名成員，子類成員將屏蔽父類對同名成員的直接訪問，這種情況叫同名隱藏，也叫重定義。（在子類成員函數中，可以使用 基類::基類成員 顯示訪問）

如果成員變量同名----->與成員變量類型是否相同無關

需要注意的是如果是成員函數的隱藏，只需要函數名相同就構成隱藏。

注意在實際中在繼承體系里面最好不要定義同名的成員變量。

// Student的_num和Person的_num構成隱藏關系 class Person { protected:string _name = "小李子"; // 姓名int _num = 111; // 身份證號 }; class Student : public Person { public:void Print(){cout << " 姓名:" << _name << endl;cout << " 身份證號:" << Person::_num << endl;cout << " 學號:" << _num << endl;} protected:int _num = 999; // 學號 }; void Test() {Student s1;s1.Print(); };// B中的fun和A中的fun不是構成重載，因為不是在同一作用域 // B中的fun和A中的fun構成隱藏，成員函數滿足函數名相同就構成隱藏。 class A { public:void fun(){cout << "func()" << endl;} }; class B : public A { public:void fun(int i){A::fun();cout << "func(int i)->" << i << endl;} }; void Test2() {B b;b.fun(10); };

派生類的默認成員函數

6個默認成員函數

派生類的構造函數必須調用基類的構造函數初始化基類的那一部分成員。

• 基類如果沒有顯示定義構造函數，子類也可以不用定義
• 基類具有無參或者全缺省的構造函數，子類也可以不用定義，除非需要做特定的事情。
• 如果基類具有帶參數的構造函數(不是全缺省)，則派生類的構造函數必須顯示提供，而且要在其初始化列表的位置，顯示的調用基類的構造函數。

派生類的拷貝構造函數必須調用基類的拷貝構造完成基類的拷貝初始化。

• 基類如果沒有定義，子類也可以不用定義—兩個類采用默認的拷貝構造函數----前提:類中不會涉及到資源管理(深拷貝)
• 基類如果顯示定義了自己拷貝構造函數，派生類也必須要顯示定義，而且要在其初始化列表的位置顯式調用。

派生類的operator=必須要調用基類的operator=完成基類的復制。

• 如果基類沒有定義，派生類也可以不用提供，除非派生類需要在賦值期間做其他操作，根據情況給出。
• 如果基類定義賦值運算符重載，一般情況下派生類也要給出，而且要在其中調用基類的賦值運算符重載。

派生類的析構函數會在被調用完成后自動調用基類的析構函數清理基類成員。因為這樣才能保證派生類對象先清理派生類成員再清理基類成員的順序。

派生類對象初始化先調用基類構造再調派生類構造。

派生類對象析構清理先調用派生類析構再調基類的析構。

/* 構造次序派生類構造函數():基類構造函數()()析構次序:派生類析構函數(){//釋放派生類資源//編譯器在派生類析構函數最后一條有效語句后插入了一條匯編代碼call 基類析構函數} */ class Person { public: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): Person(name), _num(num){cout << "Student()" << endl;}Student(const Student& s): Person(s), _num(s._num){cout << "Student(const Student& s)" << endl;}Student& operator = (const Student& s){cout << "Student& operator= (const Student& s)" << endl;if (this != &s){Person::operator =(s);_num = s._num;}return *this;}~Student(){cout << "~Student()" << endl;} protected:int _num; //學號 }; void Test() {Student s1("門", 18);Student s2(s1);Student s3("神", 17);s1 = s3; }

實現一個不能被繼承的類

// C++98中構造函數私有化，派生類中調不到基類的構造函數。則無法繼承 class NonInherit { public://成員函數需要通過對象來調，但是現在創建不出對象//所以設置稱為靜態的，可以通過類名::來調用static NonInherit GetInstance() {return NonInherit(); } private://因為基類構造函數訪問權限是private，其在子類中不能直接被調用//因此派生類的構造函數無法生成NonInherit(){} }; // C++11給出了新的關鍵字final禁止繼承 class NonInherit final {};

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

class Person { public:friend void Display(const Person& p, const Student& s); protected:string _name; // 姓名 }; class Student : public Person { protected:int _stuNum; // 學號 }; void Display(const Person& p, const Student& s) {cout << p._name << endl;cout << s._stuNum << endl; } void main() {Person p;Student s;Display(p, s); }

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

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;cout << " 人數 :" << Person::_count << endl;Student::_count = 0;cout << " 人數 :" << Person::_count << endl; }

菱形繼承及菱形虛擬繼承

單繼承

一個類只有一個基類

多繼承

一個類有多個基類(至少是兩個)
在派生類對象模型中，將多個基類中的成員變量全部繼承到子類的對象中。注意:基類中成員在子類對象中的排列次序與繼承列表的次序一致

菱形繼承

可以看出菱形繼承有數據冗余和二義性的問題。在D的對象中B成員會有兩份。

class B { public:int _b; }; class C1 :public B { public:int _c1; }; class C2 : public B { public:int _c2; }; class D:public C1 ,public C2 { public:int d; }; int main() {cout << sizeof(D) << endl;D d;//d._b = 1;//菱形繼承的缺陷，存在二義性的問題system("pause");return 0; }

從模型中可以看出D對象中有兩個_b

D d; d._b = 1;//報錯 二義性問題

解決方式:

讓其訪問明確

加上基類的作用域

d.C1::_b = 1; d.C2::_b =3;

讓B類中成員在D類中只存一份

派生類D的對象不會非常大—比較節省空間
也不會存在二義性問題

菱形虛擬繼承

虛擬繼承可以解決菱形繼承的二義性和數據冗余的問題。如上面的繼承關系，在C1和C2的繼承B時使用虛擬繼承，即可解決問題。需要注意的是，虛擬繼承不要在其他地方去使用。

class B { public:int _b; }; class C1 :virtual public B { public:int _c1; }; class C2 :virtual public B { public:int _c2; }; class D:public C1 ,public C2 { public:int d; }; int main() {cout << sizeof(D) << endl;D d;d._b = 1;system("pause");return 0; }

發現對象中多了4個字節

虛擬繼承解決數據冗余和二義性的原理

普通的單繼承,對象模型是基類在上，派生類在下，虛擬繼承派生類在上，基類在下，對象多了4個字節，在構造期間填充進去。

前4個字節是什么

class B { public:int _b; }; class D :virtual public B { public:int _d; }; int main() {cout << sizeof(D) << endl;D d;d._b = 1;d._d = 2;system("pause");return 0; }

內存窗口，前四個字節在創建完對象后，就有了，所以前4個字節一定是在構造函數時賦值。這個構造函數是由編譯器生成的默認構造函數

從匯編代碼中來思考前4個字節是干什么用的
main函數里的代碼轉匯編

D d;push 1 lea ecx,[d] call D::D (013311FEh) d._b = 1;mov eax,dword ptr [d] //取對象前4個字節中的內容mov ecx,dword ptr [eax+4] //ecx<-----8 mov dword ptr d[ecx],1 //把1賦值到d對象往后偏移8個字節的位置d._d = 2;mov dword ptr [ebp-10h],2

可以得出對象的前4個字節就是一個地址派生類對象起始位置相對于基類部分的偏移量

為什么要偏移量？在對象模型中子類對象為什么要在基類上面？

一般不用虛擬繼承，只有出現菱形繼承時，為了解決二義性問題才出現了虛擬繼承。

D d; d._b = 1; d._d = 2;

通過偏移量表格訪問最頂層基類中成員(第一個基類中的偏移量表格)

繼承總結

有了多繼承，就存在菱形繼承，有了菱形繼承就有菱形虛擬繼承，底層實現就很復雜。所以一般不建議設計出多繼承，一定不要設計出菱形繼承。否則在復雜度及性能上都有問題。

多繼承可以認為是C++的缺陷之一，很多后來的OO語言都沒有多繼承，如Java。

繼承和組合

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

class A { public:A(int a):_a(a){}void SetA(int a){_a = a;}int GetA(){return _a;} protected:int _a; };//B和A的關系:is -a class B :public A { public:B(int a, int b):A(a), _b(b){}void SetB(int b){_b = b;}int GetB(){return _b;} protected:int _b; }; //組合:C類中包含有一個A類的對象 class C { public:C(int a, int c):_a(a), _c(c){}void SetC(int c){_c = c;}void SetA(int a){_a.SetA(a);}int GetC(){return _c;} private:A _a;int _c; }; int main() {B b(1,2);b.SetA(10);C c(1, 2);c.SetA(2);system("pause");return 0; }

繼承就像是老爹，強耦合，離不開
組合就像是小三，不愛了，就離開

問題

什么是菱形繼承？菱形繼承的問題是什么？
兩個單繼承+一個多繼承
會出現二義性問題，最頂層基類的成員在最下層子類中會出現兩份。

什么是菱形虛擬繼承？如何解決數據冗余和二義性的
在繼承權限前+virtual關鍵字，
第一個是讓訪問明確，第二個是讓基類的成員在子類中只存在一份，就是菱形虛擬繼承

繼承和組合的區別？什么時候用繼承？什么時候用組合？
public繼承是一種is-a的關系。也就是說每個派生類對象都是一個基類對象。
組合是一種has-a的關系。假設B組合了A，每個B對象中都有一個A對象。
實現多態時必須用繼承，其余情況下盡量使用組合，因為高內聚低耦合

多繼承中指針偏移問題？

class Base1 { public:int _b1; }; class Base2 { public:int _b2; }; class Derive : public Base1, public Base2 { public:int _d; }; int main() {// A. p1 == p2 == p3// B. p1 < p2 < p3// C. p1 == p3 != p2// D. p1 != p2 != p3Derive d;Base1* p1 = &d;Base2* p2 = &d;Derive* p3 = &d;return 0; }

總結

以上是生活随笔為你收集整理的再谈c++中的继承的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。