定義

繼承(inheritance)機制是面向對象程序設計使代碼可以復用的最重要的手段，它允許程序員在保持原有類特性的基礎上進行擴展，增加功能，這樣產生新的類，稱派生類。

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; // 學號 }; class Teacher : public Person { protected: int _jobid; // 工號 }; int main() { Student s; Teacher t; s.Print(); t.Print(); return 0; }

這個代碼里的Student和Teacher類都是Person的派生類，學生類和老師類都對Person類的成員變量和成員函數進行了復用。

如何定義繼承

定義格式

此處Person是父類，也稱基類，Student是子類，也稱派生類。

繼承關系與訪問限定符

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

總結

1.基類private成員在派生類中無論以什么方式繼承都是不可見的。
2.基類private成員在派生類中是不能被訪問，如果基類成員不想在類外直接被訪問，但需要在派生類中能
訪問，就定義為protected。可以看出保護成員限定符是因繼承才出現的。
3.使用關鍵字class時默認的繼承方式是private，使用struct時默認的繼承方式是public，不過最好顯示的
寫出繼承方式。
4.在實際運用中一般使用都是public繼承，幾乎很少使用protetced/private繼承，也不提倡使用
protetced/private繼承，因為protetced/private繼承下來的成員都只能在派生類的類里面使用，實際中
擴展維護性不強。
5.只需記住基類中的private成員在任何繼承方式下都是不可見的，剩下的成員看繼承方式與基類中的訪問方式哪個權限低就是它在派生類里的訪問方式。

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

派生類對象可以賦值給基類的對象、指針及引用。也稱作切片或者切割。
基類對象不可以賦值給派生類對象。
基類的指針可以通過強制類型轉換賦值給派生類的指針。但是必須是基類的指針是指向派生類對象時才
是安全的。

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; }

繼承中的作用域

• 1.在繼承體系中基類和派生類都有獨立的作用域。
• 2.子類和父類中有同名成員，子類成員將屏蔽父類對同名成員的直接訪問，這種情況叫隱藏，也叫重定義。
• 3.如果是成員函數的隱藏，只需要函數名相同就構成隱藏。
• 4.注意在實際繼承體系里盡量不要定義同名的成員。

// 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 Test() { B b; b.fun(10); }

派生類的默認成員函數

• 1.派生類的構造函數必須調用基類的構造函數初始化基類的那一部分成員。如果基類沒有默認的構造函數，則必須在派生類構造函數的初始化列表階段顯示調用。
• 2.派生類的拷貝構造函數必須調用基類的拷貝構造函數以完成基類的拷貝初始化。
• 3.派生類的operator=必須調用基類的operator=完成基類的復制。
• 4.派生類的析構函數會在調用完成后自動調用基類的析構函數清理基類成員。因為這樣才能保證派生類對象先清理派生類成員再清理基類成員。
• 5.派生類對象初始化先調用基類構造再調用派生類構造。
• 6.派生類對象析構清理先調用派生類析構再調用基類析構。

class Person { public: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; };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 << "~Person()" << endl;}protected:int _num; };void Test() {Student s1("Jack", 18);Student s2(s1);Student s3("rose", 17);s1 = s3; }

繼承與友元

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

class Student; class Person { public:Person(const char* name = "person"): _name(name){}friend void Display(const Person& p, const Student& s); protected:string _name; };class Student : public Person { public:Student(const char* name = "stu", int num = 1): Person(name), _stuNum(num){} protected:int _stuNum; };void Display(const Person& p, const Student& s) {cout << p._name << endl; // 可以cout << s._name << endl; // 可以cout << s._stuNum << endl; // 不可以 }int main() {Person p;Student s;Display(p, s);return 0; }

靜態成員繼承

基類定義了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 _Course; };void TestPerson() {Student s1;Student s2;Student s3;Graduate s4;cout << "人數：" << Person::_count << endl;Student::_count = 0;cout << "人數：" << Person::_count << endl; }

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

• 單繼承：一個子類只有一個直接父類時稱這個繼承關系為單繼承
  

• 多繼承：一個子類有兩個或以上直接父類時稱這個繼承關系為多繼承
  

• 菱形繼承：菱形繼承是多繼承的一種特殊情況
  
  菱形繼承的問題：數據冗余和二義性

class Person { public:string _name; };class Student : public Person { protected:int _num; };class Teacher : public Person { protected:int _id; };class Assistant : public Student, public Teacher { protected:string _majorCourse; };void Test() {Assistant a;a._name = "Jayce"; // 此處無法執行，必須指明類域// 指定類域可以解決二義性的問題，但無法解決數據冗余a.Student::_name = "Jay";a.Teacher::_name = "J"; }int main() {Test(); }

虛擬繼承可以解決菱形繼承的二義性和數據冗余的問題

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; };void Test() {Assistant a;a._name = "Jayce";a.Student::_name = "Jay";a.Teacher::_name = "J"; }int main() {Test(); }

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

這里需要使用內存窗口觀察對象成員函數的模型

class A { public:int _a; };class B : virtual public A { public:int _b; };class C : virtual public A { public:int _c; };class D : public B, public C { public:int _d; };int main() {D d;d.B::_a = 1;d.C::_a = 2;d._b = 3;d._c = 4;d._d = 5;return 0; }

上圖是菱形虛擬繼承的內存對象成員模型：D對象中將A放到了對象組成的最下面，這個A同時屬于B和C，那么B和C如何去找到公共的A呢？這里是通過了B和C的兩個指針，指向的一張表。這兩個指針叫虛基表指針，這兩個表叫虛基表，虛基表中存的偏移量。通過偏移量可以找到末尾的A。

那么在什么情況下D中的B和C部分要去找屬于自己的A呢？下面這種賦值就需要

D d;B b = d;C c = d;

繼承和組合

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

總結

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

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