前言在 C 面向對象中經常會提到三個核心思想封裝 繼承 多態(tài)前面學習繼承的時候我們解決的是不同類之間如何建立父子關系以及如何復用基類已有的成員。但是繼承本身還沒有解決一個更關鍵的問題如果不同派生類都擁有同一個行為怎么通過一個統(tǒng)一的接口讓程序自動執(zhí)行各自不同的實現(xiàn)比如Animal ↓ ┌──────┬──────┐ Dog Cat它們都可以Speak();但是Dog::Speak() ↓ 汪汪 Cat::Speak() ↓ 喵喵如果調用者每次都需要先判斷if (類型是Dog) { ... } else if (類型是Cat) { ... }那么隨著派生類越來越多代碼會越來越復雜。多態(tài)解決的就是這個問題使用統(tǒng)一的接口根據(jù)對象真正的類型在運行時選擇對應的行為。一、多態(tài)的基本概念polymorphism翻譯成中文就是多態(tài)——多種形態(tài)。放到程序中可以簡單理解成同一個接口 不同對象 不同結果例如class Animal { public: virtual void Speak() { cout Animal::Speak() endl; } }; class Dog : public Animal { public: void Speak() override { cout 汪汪 endl; } }; class Cat : public Animal { public: void Speak() override { cout 喵喵 endl; } };我們寫一個統(tǒng)一接口void MakeSound(Animal animal) { animal.Speak(); }使用Dog dog; Cat cat; MakeSound(dog); MakeSound(cat);輸出汪汪 喵喵這里MakeSound()根本不需要知道傳進來的到底是Dog 還是 Cat它只需要按照Animal這個統(tǒng)一接口工作。真正執(zhí)行哪一個Speak()運行時再根據(jù)對象決定。這就是多態(tài)最核心的價值調用者面向統(tǒng)一接口編程而不同對象負責提供自己的實現(xiàn)。靜態(tài)多態(tài)和動態(tài)多態(tài)C 中的多態(tài)可以從“什么時候決定調用哪個函數(shù)”這個角度分成兩類。第一類是靜態(tài)多態(tài)。比如函數(shù)重載void Print(int x) { cout int: x endl; } void Print(double x) { cout double: x endl; }調用Print(10); Print(3.14);編譯器在編譯階段就已經知道Print(10) ↓ Print(int) Print(3.14) ↓ Print(double)函數(shù)模板也是類似templateclass T void Print(const T x) { cout x endl; }實際需要哪個模板實例也是編譯時根據(jù)類型確定。所以函數(shù)重載 函數(shù)模板都屬于典型的編譯期多態(tài) 靜態(tài)多態(tài)另一類就是這篇真正的重點運行時多態(tài)也叫動態(tài)多態(tài)。例如Animal* ptr dog; ptr-Speak();ptr的類型明明是Animal*但是它真正指向的是Dog于是調用的是Dog::Speak()到底執(zhí)行哪個版本并不是單純由Animal*這個靜態(tài)類型決定而與指針運行時真正指向的對象有關。可以先這樣記靜態(tài)多態(tài) ↓ 編譯的時候已經決定 動態(tài)多態(tài) ↓ 運行的時候根據(jù)真實對象決定二、多態(tài)的實現(xiàn)條件想讓 C 真正出現(xiàn)運行時多態(tài)核心條件可以概括成繼承 虛函數(shù) 重寫 基類指針或引用調用1. 必須存在繼承關系首先必須存在基類 ↓ 派生類例如class Vehicle { }; class Car : public Vehicle { };因為多態(tài)本質上依賴派生類對象可以通過基類接口進行統(tǒng)一管理。在通常的面向對象使用場景中一般采用public公有繼承來表達Car is a Vehicle這種is-a關系。2. 基類必須存在虛函數(shù)普通成員函數(shù)void Run();如果需要參與運行時多態(tài)要在基類中聲明成virtual void Run();例如class Vehicle { public: virtual void Run() { cout Vehicle running endl; } };這里virtual可以看作告訴編譯器以后調用這個函數(shù)時不一定只按照指針/引用表面的類型決定請保留運行時動態(tài)選擇的能力。虛函數(shù)只能是成員函數(shù)體系中的相應函數(shù)普通全局函數(shù)、靜態(tài)成員函數(shù)和構造函數(shù)不能成為用于這種動態(tài)派發(fā)的虛函數(shù)而析構函數(shù)可以且在多態(tài)基類中通常應該設計為虛函數(shù)。3. 派生類重寫虛函數(shù)例如class Vehicle { public: virtual void Run() { cout Vehicle running endl; } }; class Car : public Vehicle { public: void Run() override { cout Car running on road endl; } };這里Car::Run()對Vehicle::Run()進行了虛函數(shù)重寫override。一般情況下重寫要求函數(shù)名相同 參數(shù)列表相同 返回值類型相同也就是常說的三同。協(xié)變是返回值規(guī)則中的一個特殊例外后面再講。4. 通過基類指針或引用調用這是很多初學者最容易漏掉的地方。假設Vehicle v; Car c;直接v.Run(); c.Run();當然分別執(zhí)行自己的函數(shù)。但是這個例子并沒有體現(xiàn)同一個基類接口根據(jù)不同運行時對象動態(tài)決定行為。真正典型的多態(tài)寫法是Vehicle* p1 v; Vehicle* p2 c; p1-Run(); p2-Run();得到Vehicle running Car running on road或者通過引用Vehicle r1 v; Vehicle r2 c; r1.Run(); r2.Run();最值得理解的是兩個指針類型都是 Vehicle* 但是 p1 真正指向 Vehicle p2 真正指向 Car所以最終行為不同。一個完整例子#include iostream #include string using namespace std; class Vehicle { public: Vehicle(const string name) : _name(name) {} virtual void Run() { cout _name 普通行駛 endl; } virtual void Stop() { cout _name 停止 endl; } protected: string _name; }; class Car : public Vehicle { public: Car(const string name) : Vehicle(name) {} void Run() override { cout _name 在公路上行駛 endl; } void Stop() override { cout _name 汽車剎車 endl; } }; class Ship : public Vehicle { public: Ship(const string name) : Vehicle(name) {} void Run() override { cout _name 在海面航行 endl; } void Stop() override { cout _name 拋錨停船 endl; } }; void Control(Vehicle v) { v.Run(); v.Stop(); } int main() { Car car(汽車); Ship ship(輪船); Control(car); Control(ship); return 0; }這里真正體現(xiàn)了多態(tài)設計的價值以后如果增加Plane Train Bike只需要新增派生類并實現(xiàn)相同接口。Control()本身不需要跟著寫一大堆if else if else if這就是對擴展開放對已有調用邏輯盡量少修改。三、虛函數(shù)重寫虛函數(shù)重寫的基本語法并不難真正容易混的是幾個特殊規(guī)則。協(xié)變派?類重寫基類虛函數(shù)時與基類虛函數(shù)返回值類型不同。即基類虛函數(shù)返回基類對象的指針或者引 ?派?類虛函數(shù)返回派?類對象的指針或者引?時稱為協(xié)變。協(xié)變的實際意義并不?所以我們 了解?下即可。class A {}; class B : public A {}; class Person { public: virtual A* BuyTicket() { cout 買票-全價 endl; return nullptr; } }; class Student : public Person { public: virtual B* BuyTicket() { cout 買票-打折 endl; return nullptr; } }; void Func(Person* ptr) { ptr-BuyTicket(); } int main() { Person ps; Student st; Func(ps); Func(st); return 0; }虛析構函數(shù)這是多態(tài)里面非常重要的一塊。假設class Base { public: ~Base() { cout ~Base() endl; } }; class Derived : public Base { public: ~Derived() { cout ~Derived() endl; } };然后Base* p new Derived; delete p;這里非常危險。我們的真實對象是Derived但刪除時使用的是Base*如果基類析構函數(shù)不是虛函數(shù)這種通過基類指針刪除派生類對象的行為無法正確完成完整的多態(tài)析構過程。正確設計應該是class Base { public: virtual ~Base() { cout ~Base() endl; } };于是delete p;會按照Derived 析構 ↓ Base 析構完整釋放對象。例如class Base { public: Base() { _data new int[100]; } virtual ~Base() { delete[] _data; cout ~Base() endl; } private: int* _data; }; class Derived : public Base { public: Derived() { _buffer new char[1024]; } ~Derived() override { delete[] _buffer; cout ~Derived() endl; } private: char* _buffer; };使用Base* p new Derived; delete p;這樣派生類自己的_buffer和基類的_data都能夠正確釋放。原文也把“通過基類指針刪除派生類對象時使用虛析構”作為多態(tài)的重要資源安全問題。所以可以記住如果一個類準備作為多態(tài)基類使用尤其可能通過基類指針delete派生對象應當提供虛析構函數(shù)。實際工程里非常常見virtual ~Base() default;overrideC11 提供了一個非常實用的關鍵字override它并不是讓函數(shù)“變成虛函數(shù)”的關鍵字。它真正的作用是告訴編譯器我認為這個函數(shù)是在重寫基類虛函數(shù)請幫我檢查。例如class Base { public: virtual void Print(int x) { } };派生類不小心寫成class Derived : public Base { public: void Print(double x) override { } };編譯器會直接報錯。因為Base Print(int) Derived Print(double)參數(shù)不同不構成重寫。如果沒有override這類錯誤有時候很難第一時間發(fā)現(xiàn)。更典型的是拼寫錯誤virtual void Drive();結果派生類寫成void Dirve() override;因為有override編譯器馬上就會提醒沒有重寫任何基類虛函數(shù)。所以我現(xiàn)在更推薦寫void Run() override而不是單純寫void Run()override能把很多原本潛伏到運行邏輯里的錯誤提前變成編譯錯誤。原文也專門用拼寫錯誤展示了這一點。finalfinal則代表到這里結束不允許繼續(xù)重寫。例如class Base { public: virtual void Run() { } }; class Derived : public Base { public: void Run() final { } };如果繼續(xù)class Child : public Derived { public: void Run() override { } };就會編譯失敗。因為Derived::Run()已經聲明final不能繼續(xù)重寫。final也可以直接修飾類class Config final { };意味著Config 不能繼續(xù)被繼承重載、重寫和隱藏這三個概念特別容易混。可以先從“發(fā)生在哪里”判斷。重載發(fā)生在同一個作用域例如void Func(int); void Func(double);函數(shù)名相同參數(shù)列表不同。重寫發(fā)生在基類 派生類而且基類函數(shù)必須是虛函數(shù)。例如class Base { public: virtual void Func(); }; class Derived : public Base { public: void Func() override; };它服務于運行時多態(tài)隱藏也是基類和派生類之間。例如class Base { public: void Func(int); }; class Derived : public Base { public: void Func(double); };因為不在同一個作用域所以Func(int) Func(double)不是重載。派生類的Func(double)會隱藏基類同名函數(shù)。如果要訪問基類d.Base::Func(10);四、純虛函數(shù)和抽象類有時候基類根本不應該給出某個行為的默認實現(xiàn)。例如Shape表示所有圖形。但是你問Shape 的面積是多少其實沒有意義。因為Rectangle Circle Triangle每一種圖形的面積公式不同。這時候基類真正需要做的不是替所有派生類計算面積而是規(guī)定所有具體圖形都必須提供“計算面積”這個接口。于是就可以使用virtual double Area() const 0;這就是純虛函數(shù)。例如class Shape { public: virtual double Area() const 0; virtual double Perimeter() const 0; virtual ~Shape() default; };只要一個類中存在純虛函數(shù)它就屬于抽象類。例如class Rectangle : public Shape { public: Rectangle(double width, double height) : _width(width) , _height(height) { } double Area() const override { return _width * _height; } double Perimeter() const override { return 2 * (_width _height); } private: double _width; double _height; };再來一個class Circle : public Shape { public: Circle(double radius) : _radius(radius) { } double Area() const override { return 3.14159 * _radius * _radius; } double Perimeter() const override { return 2 * 3.14159 * _radius; } private: double _radius; };統(tǒng)一處理void PrintShape(const Shape shape) { cout 面積 shape.Area() endl; cout 周長 shape.Perimeter() endl; }于是Rectangle rect(10, 5); Circle circle(3); PrintShape(rect); PrintShape(circle);調用者只面向Shape工作。具體公式交給Rectangle Circle自行完成。抽象類真正重要的地方不是 0這個語法而是設計思想基類 ↓ 規(guī)定“必須做什么” 派生類 ↓ 決定“具體怎么做”這種設計在框架接口 圖形系統(tǒng) 設備驅動 插件系統(tǒng) 策略模式 工廠模式里都非常常見。五、虛函數(shù)表到這里我們已經知道多態(tài)怎么用了?，F(xiàn)在問題來了Base* p derived; p-Func();為什么一個Base*居然能在運行時找到Derived::Func()答案就涉及虛函數(shù)表 vtable 虛函數(shù)表指針 vptr虛表指針在主流 C ABI 的典型實現(xiàn)中一個具有虛函數(shù)的多態(tài)對象內部通常會包含一個隱藏的虛表指針用于找到該動態(tài)類型對應的虛函數(shù)表。原文使用 MSVC 的__vfptr名稱來解釋這一機制。例如class Base { public: virtual void Func1() { } virtual void Func2() { } private: int _data; };從概念上可以理解成Base對象 ┌────────────────┐ │ vptr │ ──────┐ ├────────────────┤ │ │ _data │ │ └────────────────┘ │ ↓ Base虛函數(shù)表 ┌─────────────┐ │ Base::Func1│ ├─────────────┤ │ Base::Func2│ └─────────────┘這里vptr負責告訴程序這個對象應該使用哪一張?zhí)摵瘮?shù)表。派生類重寫后發(fā)生什么假設class Base { public: virtual void Func1(); virtual void Func2(); }; class Derived : public Base { public: void Func1() override; };那么從典型實現(xiàn)角度可以理解成Base虛表 Func1 → Base::Func1 Func2 → Base::Func2而 Derived 的虛表Func1 → Derived::Func1 Func2 → Base::Func2因為Func1()被重寫了所以虛表中對應入口指向派生類版本。而Func2()沒有被重寫因此仍然使用基類實現(xiàn)。原文同樣以“派生類重寫后對應虛表入口指向派生版本”解釋其實現(xiàn)機制。需要注意一個嚴謹點vptr、vtable是主流編譯器實現(xiàn) C 動態(tài)多態(tài)的典型機制但 C 語言標準本身并沒有規(guī)定編譯器必須使用某一種固定的虛表內存布局。所以如下理解對象 → vptr → vtable → 虛函數(shù)地址是非常有價值的。但是不要進一步認為所有編譯器的虛表一定長得完全一樣具體布局屬于 ABI / 編譯器實現(xiàn)細節(jié)。對象為什么會變大例如class A { public: void Func() { } private: int _a; };和class B { public: virtual void Func() { } private: int _a; };B的對象通常還需要保存vptr所以B對象大小往往比沒有虛函數(shù)的A對應對象多出至少一個指針相關的空間最終大小還會受到平臺位數(shù)、ABI 和內存對齊影響。原文也通過 32 位示例展示了帶虛函數(shù)對象因為額外虛表指針而增大。例如 64 位環(huán)境中一個指針通常是8 bytes但最終sizeof(B)不能只簡單寫成成員大小 8還需要考慮內存對齊 編譯器布局 繼承結構靜態(tài)綁定和動態(tài)綁定現(xiàn)在就可以理解為什么普通函數(shù)調用和虛函數(shù)多態(tài)調用不一樣。普通函數(shù)obj.Func();如果調用目標在編譯時能夠確定就是靜態(tài)綁定?？梢源致岳斫饩幾g階段 ↓ 函數(shù)地址確定 ↓ 直接調用而Base* p derived; p-Func();當滿足運行時多態(tài)條件時需要按照對象的動態(tài)類型尋找對應虛函數(shù)實現(xiàn)p ↓ 對象 ↓ vptr ↓ 對應vtable ↓ 找到Func入口 ↓ 調用Derived::Func這就是動態(tài)綁定。多態(tài)有沒有代價當然有。最明顯的兩部分空間 時間空間方面多態(tài)對象通常多一個vptr時間方面普通調用可能直接調用函數(shù)動態(tài)派發(fā)則通常需要對象 ↓ vptr ↓ 虛表 ↓ 函數(shù)地址 ↓ 調用多了一層或多層間接訪問。不過在絕大多數(shù)正常業(yè)務代碼里不應該為了省這點開銷就放棄一個本來非常適合多態(tài)的設計。是否需要避免虛函數(shù)應該結合調用頻率 性能要求 架構復雜度 可擴展性綜合判斷。六、高頻問題與實戰(zhàn)最后把這篇里幾個非常值得單獨記住的問題放在一起。虛函數(shù)的默認參數(shù)來看一個很經典的坑class Base { public: virtual void Func(int x 10) { cout Base: x endl; } }; class Derived : public Base { public: void Func(int x 20) override { cout Derived: x endl; } };然后Derived d; Base* p d; p-Func();你覺得輸出如下結果嗎Derived: 20實際上典型結果是Derived: 10原因在于這里有兩個東西需要分開理解調用哪個虛函數(shù) ↓ 動態(tài)綁定 默認參數(shù)取哪個值 ↓ 根據(jù)調用表達式的靜態(tài)類型確定p的靜態(tài)類型是Base*所以默認參數(shù)來自Base::Func(int x 10)但是對象真正是Derived所以函數(shù)體動態(tài)派發(fā)到Derived::Func()于是最終形成Derived函數(shù)體 Base默認參數(shù)10得到Derived: 10所以實際設計虛函數(shù)時最好不要讓基類和派生類給同一個虛函數(shù)設置不同默認參數(shù)否則代碼非常容易產生誤解。利用多態(tài)實現(xiàn)計算器最后用一個稍微完整的例子把抽象類 純虛函數(shù) 重寫 基類引用 動態(tài)綁定 虛析構全部串起來。先設計一個抽象計算器#include iostream #include stdexcept using namespace std; class Calculator { public: Calculator(double left, double right) : _left(left) , _right(right) { } virtual double Calculate() const 0; virtual ~Calculator() default; protected: double _left; double _right; };這里Calculate()沒有默認實現(xiàn)。它只規(guī)定所有具體運算器必須提供計算能力。加法class AddCalculator : public Calculator { public: AddCalculator(double left, double right) : Calculator(left, right) { } double Calculate() const override { return _left _right; } };減法class SubCalculator : public Calculator { public: SubCalculator(double left, double right) : Calculator(left, right) { } double Calculate() const override { return _left - _right; } };乘法class MulCalculator : public Calculator { public: MulCalculator(double left, double right) : Calculator(left, right) { } double Calculate() const override { return _left * _right; } };除法class DivCalculator : public Calculator { public: DivCalculator(double left, double right) : Calculator(left, right) { } double Calculate() const override { if (_right 0) { throw runtime_error(除數(shù)不能為0); } return _left / _right; } };然后統(tǒng)一調用void PrintResult(const Calculator calculator) { cout calculator.Calculate() endl; }使用int main() { AddCalculator add(10, 5); SubCalculator sub(10, 5); MulCalculator mul(10, 5); DivCalculator div(10, 5); PrintResult(add); PrintResult(sub); PrintResult(mul); PrintResult(div); return 0; }輸出15 5 50 2這個例子真正體現(xiàn)的是PrintResult()完全不用關心 - * /具體是哪種運算。以后新增取模 乘方 開方只需要新增派生類 重寫 Calculate()統(tǒng)一調用接口本身不用跟著大改。這才是多態(tài)真正的價值?？偨Y這一節(jié)內容很多但整個邏輯其實可以順著一條線理解多態(tài) ↓ 一個接口多種行為 ↓ 靜態(tài)多態(tài) / 動態(tài)多態(tài) ↓ 運行時多態(tài) ↓ 繼承 virtual 重寫 基類指針/引用 ↓ 虛函數(shù)重寫 ↓ 協(xié)變 / 虛析構 / override / final ↓ 純虛函數(shù) ↓ 抽象類 ↓ vptr ↓ vtable ↓ 動態(tài)綁定 ↓ 運行時根據(jù)真實對象選擇函數(shù)如果讓我現(xiàn)在只用一句話理解 C 運行時多態(tài)我會寫基類負責規(guī)定統(tǒng)一接口派生類負責提供不同實現(xiàn)再通過基類指針或引用在運行時根據(jù)對象的真實類型選擇對應的虛函數(shù)。而底層可以進一步理解成基類指針 / 引用 ↓ 找到真實對象 ↓ 對象中的虛表指針 ↓ 對應類型的虛函數(shù)表 ↓ 找到需要調用的虛函數(shù) ↓ 完成動態(tài)綁定學到這里以后前面繼承里很多看起來只是“語法規(guī)定”的東西也開始真正串起來了。比如為什么派生類可以交給基類指針 為什么必須重寫虛函數(shù) 為什么多態(tài)基類需要虛析構 為什么對象里多了一個指針 為什么同樣一個 Base* 能表現(xiàn)出不同的行為這些問題最終都指向同一個核心通過統(tǒng)一的基類接口把“調用什么”與“具體怎么實現(xiàn)”分離開。這也是多態(tài)比單純減少幾行if/else更重要的地方——它真正改變的是程序組織和擴展代碼的方式。