1. 項目概述為什么C繼承值得萬字深談在C的龐大知識體系中繼承Inheritance絕對是一個承上啟下的核心樞紐。它不僅僅是“復用代碼”那么簡單更是面向對象編程OOP思想從抽象到具體、從藍圖到建筑的實現(xiàn)橋梁。很多初學者覺得繼承就是“兒子繼承父親的財產”這個比喻很形象但只觸及了皮毛。在實際的大型項目開發(fā)、框架設計乃至面試八股中對繼承機制的深度理解直接決定了你代碼的健壯性、擴展性和優(yōu)雅程度。我見過太多項目因為繼承關系設計混亂導致后期維護如履薄冰一個小小的改動就可能引發(fā)連鎖崩潰。也見過不少開發(fā)者只知public、protected、private的語法卻不清楚不同繼承方式下成員訪問權限的細微變化更別提虛函數(shù)表vtable、對象內存布局這些底層機制了。所以這篇萬字長文我希望能帶你穿透語法糖衣直擊繼承的本質。我們會從最基本的語法開始一步步深入到內存模型、多態(tài)實現(xiàn)、以及那些教科書上不常講但在實際編碼中會讓你“踩坑”的細節(jié)。無論你是正在啃《C Primer》的新手還是準備面試需要梳理知識的中高級開發(fā)者這篇文章都能給你帶來新的視角和實實在在的“干貨”。2. 繼承的核心概念與三種方式深度解析2.1 繼承的本質是什么與為什么繼承在C中是一種允許我們依據(jù)一個已有的類基類或父類來定義一個新類派生類或子類的機制。派生類繼承了基類的數(shù)據(jù)成員和成員函數(shù)構造/析構、賦值運算符等特殊成員函數(shù)除外并可以添加自己的新成員或重新定義覆蓋繼承來的函數(shù)。它的核心價值在于代碼復用這是最直觀的好處。通用的屬性和行為可以放在基類中避免在每個子類中重復編寫。比如一個Shape基類可以定義color、position等屬性Circle、Rectangle等派生類直接繼承無需重復聲明。接口抽象與多態(tài)基礎通過定義純虛函數(shù)基類可以成為一個接口抽象類規(guī)定派生類必須實現(xiàn)的行為。這是實現(xiàn)運行時多態(tài)通過基類指針或引用調用派生類方法的基石也是設計模式如工廠模式、策略模式廣泛應用的基礎。建立類之間的層次關系它能清晰地表達“是一個is-a”的關系。Dogis anAnimalCaris aVehicle。這種關系是現(xiàn)實世界模型在代碼中的自然映射使得程序結構更清晰更易于理解和維護。2.2 三種繼承方式的權限控制迷宮這是繼承語法中最容易混淆的部分。繼承方式public、protected、private并不改變基類成員在基類內部的原始訪問權限它控制的是基類成員在派生類中的“最低可見性”以及派生類對象對外部代碼的訪問權限。我們可以把它理解為一扇“過濾門”。為了徹底理清我們構建一個包含所有類型成員的基類Baseclass Base { public: int public_member; void public_func() {} protected: int protected_member; void protected_func() {} private: int private_member; void private_func() {} };現(xiàn)在我們分別用三種方式繼承它并觀察變化。2.2.1 Public繼承最常用的“是一個”關系class DerivedPublic : public Base { public: void test() { public_member 1; // OK: 基類public成員在派生類中仍是public public_func(); // OK protected_member 2; // OK: 基類protected成員在派生類中變?yōu)閜rotected可訪問 protected_func(); // OK // private_member 3; // 錯誤基類private成員在派生類中不可直接訪問 // private_func(); // 錯誤 } }; int main() { DerivedPublic d; d.public_member 10; // OK: 對對象而言public成員仍可訪問 d.public_func(); // OK // d.protected_member 20; // 錯誤protected成員通過對象無法訪問 // d.private_member 30; // 錯誤private成員通過對象無法訪問 }關鍵點Public繼承意味著“派生類對象就是一個基類對象”?；惖膒ublic接口仍然是派生類對象的public接口protected接口對派生類的其他成員保持可見。這是實現(xiàn)多態(tài)和接口繼承的標準方式。2.2.2 Protected繼承實現(xiàn)繼承的“黑盒”class DerivedProtected : protected Base { public: void test() { public_member 1; // OK: 但基類public成員在派生類中降級為protected public_func(); // OK protected_member 2; // OK: 基類protected成員在派生類中仍是protected protected_func(); // OK // private_member 3; // 錯誤 } }; int main() { DerivedProtected d; // d.public_member 10; // 錯誤public成員對對象已不可見變成了protected // d.public_func(); // 錯誤 // 外部代碼無法通過派生類對象訪問任何從Base繼承來的成員除了派生類自己新增的public成員。 }關鍵點Protected繼承意味著“派生類是以基類的實現(xiàn)為基礎構建的但不想對外暴露基類的接口”。所有基類的public和protected成員在派生類中都變成了protected。外部代碼無法通過派生類對象直接使用基類的任何功能。這種用法較少見通常用于實現(xiàn)某些特定的“混合類”mixin或中間輔助類。2.2.3 Private繼承純粹的“用…來實現(xiàn)”class DerivedPrivate : private Base { // ‘private’ 是默認繼承方式如果省略 public: void test() { public_member 1; // OK: 但基類public成員在派生類中降級為private public_func(); // OK protected_member 2; // OK: 基類protected成員在派生類中降級為private protected_func(); // OK // private_member 3; // 錯誤 } }; int main() { DerivedPrivate d; // d.public_member 10; // 錯誤所有繼承來的成員對對象都不可見都變成了private // d.public_func(); // 錯誤 }關鍵點Private繼承意味著“派生類僅僅是使用了基類的實現(xiàn)兩者之間沒有概念上的‘是一個’關系”。它等同于“組合”Has-a但語法更緊湊。C之父Bjarne Stroustrup曾建議優(yōu)先使用組合而非private繼承因為組合的關系更清晰。Private繼承的一個典型應用場景是實現(xiàn)“空基類優(yōu)化”當一個類需要繼承一個沒有任何數(shù)據(jù)成員的基類如某些策略類或特征類時使用private繼承可以避免額外的大小開銷。2.2.4 權限變化總結表為了更直觀我們用下表總結基類成員在派生類中的訪問權限變化基類中的訪問權限Public繼承后Protected繼承后Private繼承后publicpublicprotectedprivateprotectedprotectedprotectedprivateprivate不可訪問不可訪問不可訪問實操心得在絕大多數(shù)情況下你應該使用public繼承因為它忠實地反映了“是一個”的語義。只有在明確需要隱藏基類接口或者進行空基類優(yōu)化時才考慮protected或private繼承。在代碼審查中看到非public繼承一定要問一句“為什么”。3. 構造、析構與拷貝控制繼承鏈上的生死簿派生類對象的生命周期管理比普通對象復雜因為它包含了一個或多個基類子對象。構造函數(shù)和析構函數(shù)的調用順序以及拷貝控制成員拷貝構造、賦值運算符的行為是必須掌握的要點。3.1 構造函數(shù)與析構函數(shù)的調用順序規(guī)則很簡單但至關重要構造順序先構造基類子對象按照繼承列表中聲明的順序再構造派生類的成員變量按照在類中聲明的順序最后執(zhí)行派生類構造函數(shù)的函數(shù)體。析構順序完全相反。先執(zhí)行派生類析構函數(shù)體再析構派生類的成員變量按聲明逆序最后析構基類子對象按繼承逆序。class Base1 { public: Base1() { std::cout Base1()\n; } ~Base1() { std::cout ~Base1()\n; } }; class Base2 { public: Base2() { std::cout Base2()\n; } ~Base2() { std::cout ~Base2()\n; } }; class Member { public: Member() { std::cout Member()\n; } ~Member() { std::cout ~Member()\n; } }; class Derived : public Base1, public Base2 { // 注意繼承順序 Member m; public: Derived() { std::cout Derived()\n; } ~Derived() { std::cout ~Derived()\n; } }; int main() { Derived d; // 輸出順序 // Base1() // Base2() // Member() // Derived() // 對象d生命周期結束 // ~Derived() // ~Member() // ~Base2() // ~Base1() }注意事項如果基類沒有默認構造函數(shù)即提供了帶參數(shù)的構造函數(shù)派生類必須在其構造函數(shù)的初始化列表中顯式調用基類的構造函數(shù)并傳遞所需參數(shù)。否則編譯器會報錯。class Base { int value; public: Base(int v) : value(v) {} }; class Derived : public Base { public: // Derived() {} // 錯誤Base沒有默認構造函數(shù) Derived(int v) : Base(v) {} // 正確顯式調用基類構造函數(shù) Derived() : Base(42) {} // 正確傳遞默認值 };3.2 拷貝構造與賦值運算符的繼承困境如果你沒有為派生類定義拷貝構造函數(shù)或拷貝賦值運算符編譯器會為你合成一個。但問題來了合成版本會對基類部分做什么答案是合成版本會調用基類對應的拷貝控制成員。對于拷貝構造調用基類的拷貝構造函數(shù)對于賦值調用基類的拷貝賦值運算符。class Base { public: Base() default; Base(const Base) { std::cout Base copy ctor\n; } Base operator(const Base) { std::cout Base copy assign\n; return *this; } }; class Derived : public Base { // 沒有顯式定義拷貝控制成員 }; int main() { Derived d1; Derived d2 d1; // 輸出Base copy ctor (編譯器合成的Derived拷貝構造函數(shù)調用了Base的拷貝構造函數(shù)) d1 d2; // 輸出Base copy assign (編譯器合成的Derived拷貝賦值運算符調用了Base的拷貝賦值運算符) }但是這里有一個巨大的坑如果你在派生類中自己定義了拷貝構造函數(shù)或賦值運算符但沒有顯式處理基類部分那么基類部分將使用其默認構造函數(shù)進行初始化對于拷貝構造或者根本不會被賦值對于賦值運算符class Base { public: int data; Base() : data(0) { std::cout Base default ctor\n; } Base(const Base other) : data(other.data) { std::cout Base copy ctor\n; } Base operator(const Base other) { data other.data; std::cout Base copy assign\n; return *this; } }; class Derived : public Base { public: int extra_data; // 錯誤示例自定義拷貝構造但忘了基類 Derived(const Derived other) : extra_data(other.extra_data) { std::cout Derived copy ctor (buggy)\n; // 基類Base部分被默認構造data是0而不是other.Base::data的值 } // 錯誤示例自定義賦值運算符但忘了基類 Derived operator(const Derived other) { if (this ! other) { extra_data other.extra_data; std::cout Derived copy assign (buggy)\n; // 基類Base部分沒有被賦值data保持不變 } return *this; } }; int main() { Derived d1; d1.data 10; d1.extra_data 20; Derived d2 d1; // 輸出Base default ctor, Derived copy ctor (buggy) // d2.data 是 0 不是10BUG Derived d3; d3 d1; // 輸出Derived copy assign (buggy) // d3.data 仍然是0 不是10BUG }避坑指南黃金法則——如果你在派生類中定義了拷貝構造函數(shù)、移動構造函數(shù)、拷貝賦值運算符或移動賦值運算符并且你需要管理基類子對象的相應操作務必在初始化列表或函數(shù)體內顯式調用基類的對應版本。// 正確的派生類拷貝控制成員 class DerivedCorrect : public Base { public: int extra_data; // 正確拷貝構造 DerivedCorrect(const DerivedCorrect other) : Base(other), // 關鍵顯式調用基類拷貝構造 extra_data(other.extra_data) { std::cout Derived copy ctor (correct)\n; } // 正確拷貝賦值 DerivedCorrect operator(const DerivedCorrect other) { if (this ! other) { Base::operator(other); // 關鍵顯式調用基類拷貝賦值 extra_data other.extra_data; std::cout Derived copy assign (correct)\n; } return *this; } // 移動構造和移動賦值同理需要調用 Base(std::move(other)) 和 Base::operator(std::move(other)) };4. 多態(tài)、虛函數(shù)與動態(tài)綁定繼承的靈魂如果說繼承構建了類的骨架那么多態(tài)Polymorphism則賦予了程序靈魂。它允許我們使用基類的指針或引用來操作派生類對象并在運行時決定調用哪個函數(shù)。4.1 虛函數(shù)與override關鍵字通過在基類成員函數(shù)前加上virtual關鍵字我們將其聲明為虛函數(shù)。派生類可以提供自己的實現(xiàn)來覆蓋它。class Shape { public: virtual void draw() const { // virtual 關鍵字 std::cout Drawing a generic shape.\n; } virtual ~Shape() {} // 虛析構函數(shù)至關重要 }; class Circle : public Shape { public: void draw() const override { // C11起建議使用override關鍵字 std::cout Drawing a circle.\n; } }; class Square : public Shape { public: void draw() const override { std::cout Drawing a square.\n; } }; void drawShape(const Shape shape) { shape.draw(); // 動態(tài)綁定發(fā)生在這里 } int main() { Circle c; Square s; drawShape(c); // 輸出Drawing a circle. drawShape(s); // 輸出Drawing a square. Shape* ptr new Circle(); ptr-draw(); // 輸出Drawing a circle. delete ptr; }override關鍵字它不是必須的但強烈建議使用。它讓編譯器幫你檢查這個函數(shù)是否真的成功覆蓋了基類的虛函數(shù)如果基類沒有同名同參的虛函數(shù)或者你拼寫錯了編譯器會報錯。這能防止因疏忽導致的錯誤。虛析構函數(shù)這是必須記住的規(guī)則。如果一個類有可能被繼承并且會通過基類指針來刪除派生類對象那么基類的析構函數(shù)必須是虛函數(shù)。否則通過基類指針刪除派生類對象會導致派生類的析構函數(shù)不被調用從而可能引發(fā)資源泄漏內存、文件句柄等。class BaseWithoutVirtualDtor { public: ~BaseWithoutVirtualDtor() { std::cout Base dtor\n; } }; class DerivedBWV : public BaseWithoutVirtualDtor { public: ~DerivedBWV() { std::cout Derived dtor\n; } }; int main() { BaseWithoutVirtualDtor* ptr new DerivedBWV(); delete ptr; // 輸出Base dtor // DerivedBWV的析構函數(shù)沒有被調用內存泄漏風險 }4.2 虛函數(shù)表vtable與動態(tài)綁定原理淺析理解虛函數(shù)的底層實現(xiàn)能讓你更深刻地理解多態(tài)的成本和限制。每個包含虛函數(shù)的類或從包含虛函數(shù)的類派生而來都有一個虛函數(shù)表。這是一個編譯器在編譯時生成的靜態(tài)數(shù)組其中存放了該類所有虛函數(shù)的地址。每個該類的對象在內存布局中隱含地包含一個指向其所屬類的虛函數(shù)表的指針通常稱為vptr。當我們通過基類指針或引用調用虛函數(shù)時程序會通過對象的vptr找到對應的虛函數(shù)表。在虛函數(shù)表中查找該虛函數(shù)的地址。調用該地址指向的函數(shù)。這個過程發(fā)生在運行時因此稱為動態(tài)綁定或晚期綁定。與之相對的是非虛函數(shù)的靜態(tài)綁定在編譯時就確定了調用地址。性能考量虛函數(shù)調用比普通函數(shù)調用多一次間接尋址通過vptr和vtable并且通常不利于編譯器內聯(lián)優(yōu)化。在性能極度敏感的代碼段如內層循環(huán)需要謹慎使用。但現(xiàn)代CPU的分支預測和緩存機制已經很大程度上優(yōu)化了這種開銷在大多數(shù)場景下為了設計清晰而使用虛函數(shù)是完全值得的。4.3 純虛函數(shù)與抽象基類當一個虛函數(shù)被賦值為0時它就成了純虛函數(shù)。包含至少一個純虛函數(shù)的類稱為抽象基類。抽象基類不能被實例化它的作用是為所有派生類定義一個統(tǒng)一的接口。class AbstractShape { public: virtual double area() const 0; // 純虛函數(shù) virtual void draw() const 0; // 它可以有非虛函數(shù)和成員變量 void printInfo() const { std::cout Area: area() std::endl; } virtual ~AbstractShape() default; }; // class ConcreteShape : public AbstractShape {}; // 錯誤沒有實現(xiàn)area()和draw()仍是抽象類 class ConcreteCircle : public AbstractShape { double radius; public: ConcreteCircle(double r) : radius(r) {} double area() const override { return 3.14159 * radius * radius; } void draw() const override { std::cout O\n; } }; int main() { // AbstractShape s; // 錯誤不能實例化抽象類 AbstractShape* shape new ConcreteCircle(5.0); // OK shape-printInfo(); // 輸出Area: 78.5398 delete shape; }抽象基類是設計模式中“依賴倒置”原則的關鍵工具它使得高層模塊不依賴于低層模塊的具體實現(xiàn)而依賴于抽象接口。5. 多重繼承、菱形繼承與虛繼承高級主題與陷阱C支持一個類從多個基類繼承這就是多重繼承。它功能強大但也帶來了著名的“菱形繼承”問題。5.1 多重繼承的基本用法class Printer { public: void print(const std::string doc) { std::cout Printing: doc std::endl; } }; class Scanner { public: void scan() { std::cout Scanning...\n; } }; class MultiFunctionDevice : public Printer, public Scanner { // 繼承了Printer::print 和 Scanner::scan }; int main() { MultiFunctionDevice mfd; mfd.print(report); mfd.scan(); }5.2 菱形繼承問題與虛繼承解決方案考慮這樣一個繼承體系Animal-Bird,Animal-Mammal,Bird和Mammal-Bat蝙蝠既是鳥又是哺乳動物這里僅為示例。這就形成了菱形結構。class Animal { public: int age; Animal() : age(0) {} }; class Bird : public Animal { public: void fly() {} }; class Mammal : public Animal { public: void run() {} }; class Bat : public Bird, public Mammal { };問題來了Bat對象內部包含兩個Animal子對象分別來自Bird和Mammal。這會導致數(shù)據(jù)冗余Bat對象有兩份age。二義性直接訪問Bat對象的age成員編譯器不知道你指的是哪一個。Bat b; // b.age 5; // 錯誤對成員‘age’的請求不明確 b.Bird::age 3; // 必須指定路徑 b.Mammal::age 4; // 這是另一個不同的age std::cout b.Bird::age , b.Mammal::age std::endl; // 輸出3, 4這顯然不是我們想要的生物學模型。我們希望Bat只繼承一份Animal的屬性。解決方案是虛繼承。class Animal { public: int age; Animal() : age(0) {} }; class Bird : virtual public Animal { // 虛繼承 public: void fly() {} }; class Mammal : virtual public Animal { // 虛繼承 public: void run() {} }; class Bat : public Bird, public Mammal { }; int main() { Bat b; b.age 10; // OK現(xiàn)在只有一份age b.Bird::age 20; // 修改的是同一份 b.Mammal::age 30; // 修改的還是同一份 std::cout b.age std::endl; // 輸出30 // 通過不同路徑訪問的都是同一個基類子對象 std::cout b.Bird::age , b.Mammal::age std::endl; // 地址相同 }虛繼承通過在繼承時使用virtual關鍵字確保在最終的派生類中虛基類這里是Animal的子對象只存在一份。編譯器會通過額外的指針虛基類指針來管理這份共享數(shù)據(jù)。注意事項與代價初始化責任在虛繼承體系中最底層的派生類如Bat負責直接初始化虛基類Animal。中間類Bird和Mammal對虛基類構造函數(shù)的調用會被忽略。性能開銷虛繼承引入了額外的間接層虛基類指針訪問虛基類成員比訪問普通基類成員稍慢。復雜性虛繼承顯著增加了對象內存布局和初始化順序的復雜性。實操建議除非你明確遇到了菱形繼承問題并且需要共享基類狀態(tài)否則盡量避免使用多重繼承尤其是虛繼承。很多時候通過組合將一個類作為成員或者使用純接口類只包含純虛函數(shù)沒有數(shù)據(jù)成員的多重繼承是更清晰、更安全的設計。6. 實戰(zhàn)中的繼承設計模式與經典問題6.1 繼承與組合的選擇“是一個” vs “有一個”這是面向對象設計的一個基本原則。繼承是一個Caris aVehicle。用于表示嚴格的分類學上的關系。派生類對象可以完全替代基類對象里氏替換原則。組合有一個Carhas anEngine。用于表示整體與部分的關系或者一個類使用另一個類的功能。優(yōu)先使用組合。組合比繼承更具靈活性耦合度更低。繼承破壞了封裝性派生類依賴于基類的實現(xiàn)細節(jié)而組合只是通過接口進行交互。只有當派生類真正“是”一種更特殊的基類并且需要多態(tài)行為時才使用public繼承。6.2 切片問題Object Slicing這是C繼承中一個常見的陷阱。當派生類對象被按值賦值給基類對象時會發(fā)生“切片”派生類特有的部分會被“切掉”只保留基類子對象。class Base { public: int base_data; Base(int x) : base_data(x) {} virtual void print() const { std::cout Base: base_data std::endl; } }; class Derived : public Base { public: int derived_data; Derived(int x, int y) : Base(x), derived_data(y) {} void print() const override { std::cout Derived: base_data , derived_data std::endl; } }; int main() { Derived d(1, 2); Base b d; // 切片發(fā)生在這里 b.print(); // 輸出Base: 1 (虛函數(shù)表也被“切”了調用的是Base::print) // b.derived_data; // 錯誤derived_data不存在于b中 Base ref d; // 引用不會切片 ref.print(); // 輸出Derived: 1, 2 (多態(tài)正常工作) Base* ptr d; // 指針不會切片 ptr-print(); // 輸出Derived: 1, 2 }避坑指南在需要多態(tài)的場景下始終使用基類的指針或引用來操作派生類對象避免按值傳遞或賦值。函數(shù)參數(shù)應設計為Base或Base*而不是Base。6.3 名字隱藏Name Hiding派生類中定義的成員包括非虛函數(shù)會隱藏基類中同名的成員即使參數(shù)列表不同。class Base { public: void func(int x) { std::cout Base::func(int)\n; } void func(double x) { std::cout Base::func(double)\n; } }; class Derived : public Base { public: void func(const char* s) { std::cout Derived::func(const char*)\n; } // 隱藏了Base::func(int)和Base::func(double) }; int main() { Derived d; d.func(hello); // OK: 調用Derived::func // d.func(10); // 錯誤Base::func(int)被隱藏了 // d.func(3.14); // 錯誤Base::func(double)被隱藏了 d.Base::func(10); // OK: 使用作用域解析運算符顯式調用 d.Base::func(3.14); // OK }如果你希望基類的重載函數(shù)在派生類中依然可見需要在派生類中使用using聲明。class DerivedCorrect : public Base { public: using Base::func; // 引入Base中所有名為func的函數(shù) void func(const char* s) { std::cout Derived::func(const char*)\n; } // 現(xiàn)在Base::func(int)和Base::func(double)也可見了 }; int main() { DerivedCorrect d; d.func(hello); // 調用Derived::func d.func(10); // 調用Base::func(int) d.func(3.14); // 調用Base::func(double) }7. C11/14/17/20中關于繼承的現(xiàn)代特性現(xiàn)代C引入了一些特性讓繼承的使用更安全、更清晰。7.1final與override關鍵字override如前所述用于顯式標記覆蓋的虛函數(shù)讓編譯器檢查。final可以用于類或虛函數(shù)。用于類表示該類不能被繼承。class Derived final : public Base {};用于虛函數(shù)表示該虛函數(shù)在派生類中不能被進一步覆蓋。virtual void func() const final;7.2 繼承構造函數(shù) (C11)在C11之前派生類無法直接繼承基類的構造函數(shù)除非使用using聲明但那也有局限。C11允許通過using Base::Base;來繼承基類的所有構造函數(shù)除了默認、拷貝、移動構造因為它們有特殊規(guī)則。class Base { public: Base(int) {} Base(int, double) {} }; class Derived : public Base { public: using Base::Base; // 繼承Base的所有構造函數(shù) // 編譯器會為Derived生成 // Derived(int x) : Base(x) {} // Derived(int x, double y) : Base(x, y) {} // 注意派生類新增的成員變量需要自己初始化如果有默認初始化則沒問題否則需要額外處理。 }; int main() { Derived d1(42); // OK調用繼承的Base(int) Derived d2(42, 3.14); // OK調用繼承的Base(int, double) }7.3 委托構造函數(shù)與繼承委托構造函數(shù)在同一個類中一個構造函數(shù)調用另一個可以與繼承構造函數(shù)結合提供更靈活的初始化方式。class MyDerived : public Base { std::string name; public: using Base::Base; // 繼承Base的構造函數(shù) // 自定義構造函數(shù)委托給繼承的構造函數(shù) MyDerived(int x, const std::string n) : Base(x), name(n) {} };理解C的繼承就像掌握了一把打開面向對象大門的鑰匙。它連接了抽象與具體靜態(tài)與動態(tài)。從簡單的語法到復雜的內存模型從清晰的public繼承到需要慎用的多重虛繼承每一步都需要仔細權衡。記住繼承是一種強耦合關系設計時應遵循“組合優(yōu)于繼承”的原則。但在需要表達“是一個”關系并利用多態(tài)時它又是無可替代的工具。希望這篇近萬字的梳理能幫你構建起關于C繼承的清晰、穩(wěn)固的知識體系在未來的項目中寫出更健壯、更優(yōu)雅的代碼。在實際編碼中多畫UML圖理清關系多思考“是不是真的需要繼承”多用override和final讓意圖更明確這些習慣會讓你受益匪淺。