吃透 C++ 多态：从底层虚函数表到实战落地，一篇全搞定！

class 卑微码农:
    def __init__(self):
        self.技能 = ['能读懂十年前祖传代码', '擅长用Ctrl+C/V搭建世界', '信奉"能跑就别动"的玄学']
        self.发量 = 100  # 初始发量
        self.咖啡因耐受度 = '极限'
        
    def 修Bug(self, bug):
        try:
            # 试图用玄学解决问题
            if bug.严重程度 == '离谱':
                print("这一定是环境问题！")
            else:
                print("让我看看是谁又没写注释...哦，是我自己。")
        except Exception as e:
            # 如果try块都救不了，那就...
            print("重启一下试试？")
            self.发量 -= 1  # 每解决一个bug，头发-1
 
 
# 实例化一个我
我 = 卑微码农()

引言

在 C++ 开发中，“多态” 是绕不开的核心特性，也是面试官高频追问的考点。很多开发者能用虚函数实现简单多态，却搞不懂底层原理；知道多态能提升代码扩展性，却在实际项目中用得磕磕绊绊。本文从 “为什么需要多态” 切入，层层拆解静态多态与动态多态的实现逻辑，结合大量实战示例讲清用法，再深挖虚函数表的底层机制，最后盘点常见坑点与优化技巧，帮你彻底吃透 C++ 多态。

一、先搞懂：为什么需要多态？—— 解决 “重复代码 + 扩展性差” 的痛点

在没有多态的日子里，我们写代码常常陷入 “复制粘贴” 的困境，而且后续维护堪称灾难。举个真实场景：

假设要开发一个图形计算程序，需要计算圆形、矩形、三角形的面积。如果不用多态，代码可能是这样的：

#include <iostream>
using namespace std;

// 圆形
class Circle {
public:
    double radius;
    double calculateArea() {
        return 3.14 * radius * radius;
    }
};

// 矩形
class Rectangle {
public:
    double width, height;
    double calculateArea() {
        return width * height;
    }
};

// 三角形
class Triangle {
public:
    double base, height;
    double calculateArea() {
        return 0.5 * base * height;
    }
};

// 计算所有图形面积的函数
void calculateAllAreas(Circle* circles, int cLen, 
                       Rectangle* rects, int rLen, 
                       Triangle* tris, int tLen) {
    // 计算圆形面积
    for (int i = 0; i < cLen; i++) {
        cout << "圆形面积：" << circles[i].calculateArea() << endl;
    }
    // 计算矩形面积
    for (int i = 0; i < rLen; i++) {
        cout << "矩形面积：" << rects[i].calculateArea() << endl;
    }
    // 计算三角形面积
    for (int i = 0; i < tLen; i++) {
        cout << "三角形面积：" << tris[i].calculateArea() << endl;
    }
}

int main() {
    Circle circles[2] = {{1.0}, {2.0}};
    Rectangle rects[2] = {{2.0, 3.0}, {4.0, 5.0}};
    Triangle tris[2] = {{3.0, 4.0}, {5.0, 6.0}};
    
    calculateAllAreas(circles, 2, rects, 2, tris, 2);
    return 0;
}

这段代码看似能跑，但问题很明显：

代码重复：每个图形类都有calculateArea方法，计算总面积的函数要写三段类似的循环；
扩展性极差：如果新增 “梯形”“菱形”，不仅要写新类，还要修改calculateAllAreas函数，违反 “开闭原则”（对扩展开放，对修改关闭）；
维护成本高：后续若要修改面积计算逻辑（比如 π 取 3.1415926），需要逐个修改所有图形类的方法。

而多态就能完美解决这些问题：通过抽象基类定义统一接口，派生类实现具体逻辑，调用时只需通过基类指针 / 引用，就能自动匹配派生类的实现。修改后的代码会简洁很多，后续新增图形只需加派生类，无需改动原有代码 —— 这就是多态的核心价值：统一接口、隔离变化、提升扩展性。

二、C++ 多态的两种形式：静态多态 vs 动态多态

C++ 多态分为 “静态多态” 和 “动态多态”，两者实现原理和适用场景完全不同，很多开发者会混淆，我们逐个拆解。

2.1 静态多态：编译时确定调用逻辑

静态多态是编译阶段就确定要调用的函数，核心实现方式有两种：函数重载和模板。

2.1.1 函数重载：同名函数的 “差异化调用”

函数重载是指在同一个作用域内，定义多个同名函数，但参数类型、参数个数或参数顺序不同。编译器会根据调用时的实参，匹配对应的函数。

实战示例：计算器的加减乘除

#include <iostream>
using namespace std;

// 加法：int类型
int calculate(int a, int b) {
    return a + b;
}

// 加法：double类型（参数类型不同）
double calculate(double a, double b) {
    return a + b;
}

// 减法：两个参数
int calculate(int a, int b, bool isSubtract) {
    if (isSubtract) return a - b;
    return a + b;
}

int main() {
    cout << calculate(10, 20) << endl;          // 调用int版本加法，输出30
    cout << calculate(10.5, 20.3) << endl;     // 调用double版本加法，输出30.8
    cout << calculate(100, 30, true) << endl;  // 调用减法版本，输出70
    return 0;
}

关键要点：

函数重载的匹配规则：先匹配参数类型完全一致的，再匹配可隐式转换的（比如 int 可转 double）；
仅返回值不同不能构成重载（编译器无法区分调用）；
作用域不同不构成重载（比如类内和类外的同名函数）。

2.1.2 模板：泛型编程的 “万能模板”

模板是静态多态的另一种形式，通过 “类型参数化” 实现通用代码，编译器会在编译时为不同类型生成具体的函数 / 类。

实战示例：通用交换函数

#include <iostream>
using namespace std;

// 模板函数：交换任意类型的两个变量
template <typename T>
void swapValue(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int a = 10, b = 20;
    swapValue(a, b);
    cout << "a=" << a << ", b=" << b << endl;  // 输出a=20, b=10

    double c = 1.5, d = 2.5;
    swapValue(c, d);
    cout << "c=" << c << ", d=" << d << endl;  // 输出c=2.5, d=1.5

    string s1 = "hello", s2 = "world";
    swapValue(s1, s2);
    cout << "s1=" << s1 << ", s2=" << s2 << endl;  // 输出s1=world, s2=hello
    return 0;
}

关键要点：

模板的实例化是编译时完成的，属于 “静态绑定”；
模板支持特化（为特定类型定制实现），比如为char*类型的字符串交换单独写特化版本；
优点是代码复用性极高，缺点是编译后二进制体积会增大（每个类型都生成独立代码）。

2.1.3 静态多态的核心特点

绑定时机：编译时绑定（静态绑定），编译器在编译阶段就确定调用哪个函数；
优点：调用效率高，无运行时开销；
缺点：扩展性差，无法应对运行时动态变化的类型（比如根据用户输入决定调用哪个函数）。

2.2 动态多态：运行时确定调用逻辑

动态多态是运行阶段才确定要调用的函数，核心是 “虚函数” 机制。它能实现 “基类指针 / 引用指向派生类对象时，调用派生类的重写函数”，这是 C++ 面向对象的核心特性之一。

2.2.1 动态多态的三大条件

要实现动态多态，必须满足以下三个条件：

基类中定义虚函数（用virtual关键字修饰）；
派生类重写基类的虚函数（函数名、参数列表、返回值完全一致，协变除外）；
通过基类指针或引用调用虚函数。

实战示例：动物叫声模拟器

#include <iostream>
using namespace std;

// 基类：动物
class Animal {
public:
    // 虚函数：叫声
    virtual void makeSound() {
        cout << "动物发出叫声" << endl;
    }
};

// 派生类：狗
class Dog : public Animal {
public:
    // 重写基类虚函数
    void makeSound() override {  // override关键字显式声明重写，建议加上
        cout << "汪汪汪！" << endl;
    }
};

// 派生类：猫
class Cat : public Animal {
public:
    void makeSound() override {
        cout << "喵喵喵！" << endl;
    }
};

// 派生类：鸟
class Bird : public Animal {
public:
    void makeSound() override {
        cout << "叽叽喳喳！" << endl;
    }
};

// 统一调用接口：接收基类引用
void animalCry(Animal& animal) {
    animal.makeSound();  // 运行时确定调用哪个派生类的方法
}

int main() {
    Dog dog;
    Cat cat;
    Bird bird;

    animalCry(dog);   // 输出“汪汪汪！”
    animalCry(cat);   // 输出“喵喵喵！”
    animalCry(bird);  // 输出“叽叽喳喳！”

    // 基类指针指向派生类对象
    Animal* pAnimal = new Dog();
    pAnimal->makeSound();  // 输出“汪汪汪！”
    delete pAnimal;

    pAnimal = new Cat();
    pAnimal->makeSound();  // 输出“喵喵喵！”
    delete pAnimal;

    return 0;
}

这段代码完美体现了动态多态的优势：animalCry函数只需接收基类引用，就能自动调用不同派生类的makeSound方法。如果后续新增 “猪”“牛” 等动物，只需新增派生类并重写makeSound，无需修改animalCry函数 —— 完全符合 “开闭原则”。

2.2.2 虚函数的关键细节

override关键字：显式声明函数重写基类虚函数，若写错函数名 / 参数，编译器会报错（避免手误）；
final关键字：禁止派生类重写该虚函数（比如virtual void makeSound() final）；
协变返回值：重写虚函数时，返回值可以是基类虚函数返回值的派生类指针 / 引用（比如基类返回Animal*，派生类返回Dog*）；
静态函数不能是虚函数：静态函数属于类，不属于对象，而虚函数需要通过对象的虚指针调用。

三、深挖底层：动态多态是如何实现的？—— 虚函数表与虚指针

很多开发者只会用虚函数，却不知道底层是怎么工作的。其实动态多态的核心是 “虚函数表（vtable）” 和 “虚指针（vptr）”，我们一步步拆解。

3.1 核心概念：虚函数表与虚指针

虚函数表（vtable）：每个包含虚函数的类（基类和派生类）都会有一个专属的虚函数表，本质是一个存储虚函数地址的数组；
虚指针（vptr）：每个包含虚函数的类的对象，都会隐含一个虚指针（通常在对象内存的最前面），指向所属类的虚函数表。

3.2 内存布局与调用流程

我们以 “Animal-Dog” 为例，分析内存布局和虚函数调用过程。

3.2.1 内存布局

基类 Animal：包含虚函数makeSound，所以 Animal 类有一个虚函数表，Animal 对象有一个虚指针 vptr，指向 Animal 的 vtable；
派生类 Dog：继承自 Animal，重写了makeSound函数，所以 Dog 类有自己的虚函数表，其中makeSound的地址被替换为 Dog 的实现地址；Dog 对象的 vptr 指向 Dog 的 vtable。

简化内存布局图：

// Animal对象内存
+----------+
| vptr     |  -->  Animal的vtable：[&Animal::makeSound]
+----------+

// Dog对象内存（继承Animal的vptr，覆盖vtable内容）
+----------+
| vptr     |  -->  Dog的vtable：[&Dog::makeSound]
+----------+

3.2.2 虚函数调用流程

当执行Animal* p = new Dog(); p->makeSound();时，流程如下：

通过指针 p 访问 Dog 对象的 vptr；
由 vptr 找到 Dog 的虚函数表 vtable；
在 vtable 中找到makeSound函数的地址（Dog 的实现地址）；
调用该地址对应的函数。

正因为这个过程是在运行时完成的，所以才能实现 “基类指针指向不同派生类对象，调用不同函数” 的效果。

3.3 实战验证：查看虚函数表（Linux 下 gdb 调试）

光说不练假把式，我们用 gdb 调试来验证虚函数表的存在。

步骤 1：编写测试代码（保存为 polymorphism.cpp）

#include <iostream>
using namespace std;

class Base {
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
};

class Derived : public Base {
public:
    void func1() override { cout << "Derived::func1" << endl; }
    virtual void func3() { cout << "Derived::func3" << endl; }
};

int main() {
    Base* p = new Derived();
    p->func1();
    delete p;
    return 0;
}

步骤 2：编译生成可执行文件（带调试信息）

g++ polymorphism.cpp -o poly -g

步骤 3：gdb 调试查看虚函数表

gdb ./poly
(gdb) break main  # 在main函数打断点
(gdb) run         # 运行程序，停在main断点
(gdb) n           # 执行到Base* p = new Derived();
(gdb) p *p        # 查看p指向的对象内容
$1 = {_vptr.Base = 0x555555554040 <vtable for Derived+16>}  # 虚指针指向Derived的vtable

# 查看虚函数表内容（0x555555554040是vptr地址，强转为函数指针数组）
(gdb) x/3wf 0x555555554040
0x555555554040: 0x5555555541d6  # Derived::func1的地址
0x555555554044: 0x5555555541f6  # Base::func2的地址（未重写，继承自Base）
0x555555554048: 0x555555554216  # Derived::func3的地址（新增虚函数）

从调试结果可以清晰看到：

Derived 的虚函数表中，func1的地址是自己的实现，func2是继承自 Base 的实现，func3是新增的虚函数；
虚指针确实指向了派生类的虚函数表，这就是动态多态的底层原理。

3.4 继承中的虚函数表变化

当派生类继承多个基类（多继承）时，虚函数表的结构会更复杂，但核心逻辑不变：每个基类都有自己的虚函数表，派生类对象会有多个虚指针，分别指向对应的虚函数表。

多继承示例：

#include <iostream>
using namespace std;

// 基类1
class Base1 {
public:
    virtual void func1() { cout << "Base1::func1" << endl; }
};

// 基类2
class Base2 {
public:
    virtual void func2() { cout << "Base2::func2" << endl; }
};

// 派生类：多继承Base1和Base2
class Derived : public Base1, public Base2 {
public:
    void func1() override { cout << "Derived::func1" << endl; }
    void func2() override { cout << "Derived::func2" << endl; }
};

int main() {
    Derived d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    p1->func1();  // 输出“Derived::func1”
    p2->func2();  // 输出“Derived::func2”
    return 0;
}

多继承下的虚函数表：

Derived 对象有两个虚指针，分别指向 Base1 的虚函数表和 Base2 的虚函数表；
重写的func1和func2分别替换对应虚函数表中的地址。

四、实战进阶：多态在项目中的典型应用场景

多态不是花架子，在实际项目中应用广泛，以下是几个高频场景。

4.1 场景 1：接口封装与插件化开发

多态可实现 “接口与实现分离”，便于插件化扩展。比如开发一个日志系统，支持控制台日志、文件日志、数据库日志。

实现代码：

#include <iostream>
#include <string>
#include <fstream>
using namespace std;

// 抽象基类：日志接口
class Logger {
public:
    virtual ~Logger() {}  // 析构函数设为虚函数，确保派生类析构被调用
    virtual void log(const string& message) = 0;  // 纯虚函数，定义接口
};

// 派生类：控制台日志
class ConsoleLogger : public Logger {
public:
    void log(const string& message) override {
        cout << "[Console] " << message << endl;
    }
};

// 派生类：文件日志
class FileLogger : public Logger {
private:
    ofstream file;
public:
    FileLogger(const string& filename) {
        file.open(filename, ios::app);  // 追加模式打开文件
    }
    ~FileLogger() {
        file.close();
    }
    void log(const string& message) override {
        file << "[File] " << message << endl;
    }
};

// 派生类：数据库日志（模拟）
class DatabaseLogger : public Logger {
public:
    void log(const string& message) override {
        cout << "[Database] " << message << " (已写入数据库)" << endl;
    }
};

// 日志管理器：统一管理日志输出
class LogManager {
private:
    Logger* logger;
public:
    LogManager(Logger* l) : logger(l) {}
    ~LogManager() {
        delete logger;
    }
    void writeLog(const string& message) {
        logger->log(message);
    }
};

int main() {
    // 控制台日志
    LogManager consoleLog(new ConsoleLogger());
    consoleLog.writeLog("程序启动成功");

    // 文件日志
    LogManager fileLog(new FileLogger("app.log"));
    fileLog.writeLog("用户登录：admin");

    // 数据库日志
    LogManager dbLog(new DatabaseLogger());
    dbLog.writeLog("数据更新：用户信息修改");

    return 0;
}

核心优势：

新增日志类型（如网络日志）时，只需新增派生类实现log方法，无需修改LogManager；
切换日志输出方式时，只需更换Logger的实现类，调用代码无需改动。

4.2 场景 2：回调函数与事件处理

多态可替代函数指针实现回调，代码更易维护。比如开发一个按钮控件，支持点击事件回调。

实现代码：

#include <iostream>
#include <string>
using namespace std;

// 抽象基类：事件回调接口
class EventListener {
public:
    virtual ~EventListener() {}
    virtual void onButtonClick(const string& buttonName) = 0;
};

// 按钮类
class Button {
private:
    string name;
    EventListener* listener;
public:
    Button(const string& n) : name(n), listener(nullptr) {}
    void setListener(EventListener* l) {
        listener = l;
    }
    // 模拟按钮点击
    void click() {
        cout << "按钮[" << name << "]被点击" << endl;
        if (listener != nullptr) {
            listener->onButtonClick(name);  // 回调事件处理函数
        }
    }
};

// 派生类：登录按钮事件处理
class LoginButtonListener : public EventListener {
public:
    void onButtonClick(const string& buttonName) override {
        cout << "处理[" << buttonName << "]点击：执行登录逻辑..." << endl;
    }
};

// 派生类：注册按钮事件处理
class RegisterButtonListener : public EventListener {
public:
    void onButtonClick(const string& buttonName) override {
        cout << "处理[" << buttonName << "]点击：执行注册逻辑..." << endl;
    }
};

int main() {
    Button loginBtn("登录");
    Button registerBtn("注册");

    LoginButtonListener loginListener;
    RegisterButtonListener registerListener;

    loginBtn.setListener(&loginListener);
    registerBtn.setListener(&registerListener);

    loginBtn.click();     // 输出按钮点击信息，并执行登录逻辑
    registerBtn.click();  // 输出按钮点击信息，并执行注册逻辑

    return 0;
}

4.3 场景 3：策略模式（算法动态切换）

策略模式是多态的典型应用，可实现 “算法家族的动态切换”。比如电商平台的促销活动，支持满减、打折、优惠券等不同策略。

实现代码：

#include <iostream>
#include <string>
using namespace std;

// 抽象基类：促销策略接口
class PromotionStrategy {
public:
    virtual ~PromotionStrategy() {}
    virtual double calculateDiscount(double originalPrice) = 0;
    virtual string getStrategyName() = 0;
};

// 派生类：满减策略（满100减20，满200减50）
class FullReduceStrategy : public PromotionStrategy {
public:
    double calculateDiscount(double originalPrice) override {
        if (originalPrice >= 200) {
            return originalPrice - 50;
        } else if (originalPrice >= 100) {
            return originalPrice - 20;
        }
        return originalPrice;
    }
    string getStrategyName() override {
        return "满减优惠";
    }
};

// 派生类：打折策略（8折）
class DiscountStrategy : public PromotionStrategy {
public:
    double calculateDiscount(double originalPrice) override {
        return originalPrice * 0.8;
    }
    string getStrategyName() override {
        return "8折优惠";
    }
};

// 派生类：优惠券策略（固定减10元）
class CouponStrategy : public PromotionStrategy {
public:
    double calculateDiscount(double originalPrice) override {
        return originalPrice - 10;
    }
    string getStrategyName() override {
        return "10元优惠券";
    }
};

// 上下文类：商品订单
class Order {
private:
    double originalPrice;
    PromotionStrategy* strategy;
public:
    Order(double price, PromotionStrategy* s) : originalPrice(price), strategy(s) {}
    ~Order() {
        delete strategy;
    }
    // 计算最终价格
    double calculateFinalPrice() {
        cout << "原价：" << originalPrice << "元，使用" << strategy->getStrategyName() << endl;
        return strategy->calculateDiscount(originalPrice);
    }
};

int main() {
    // 满减策略
    Order order1(250, new FullReduceStrategy());
    cout << "最终价格：" << order1.calculateFinalPrice() << "元" << endl;

    // 打折策略
    Order order2(150, new DiscountStrategy());
    cout << "最终价格：" << order2.calculateFinalPrice() << "元" << endl;

    // 优惠券策略
    Order order3(80, new CouponStrategy());
    cout << "最终价格：" << order3.calculateFinalPrice() << "元" << endl;

    return 0;
}

输出结果：

原价：250元，使用满减优惠
最终价格：200元
原价：150元，使用8折优惠
最终价格：120元
原价：80元，使用10元优惠券
最终价格：70元

五、避坑指南：多态开发中的常见错误与解决方案

多态虽强大，但容易踩坑，以下是几个高频错误及应对方法。

5.1 坑点 1：析构函数未设为虚函数，导致内存泄漏

问题现象：基类指针指向派生类对象，delete 指针时，只调用基类析构函数，派生类析构函数未调用，导致内存泄漏。

错误代码：

class Base {
public:
    ~Base() {  // 非虚析构
        cout << "Base::~Base" << endl;
    }
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() {
        data = new int[10];  // 动态分配内存
    }
    ~Derived() {  // 派生类析构，释放内存
        delete[] data;
        cout << "Derived::~Derived" << endl;
    }
};

int main() {
    Base* p = new Derived();
    delete p;  // 只调用Base::~Base，Derived的data未释放，内存泄漏
    return 0;
}

解决方案：将基类析构函数设为虚函数。

class Base {
public:
    virtual ~Base() {  // 虚析构
        cout << "Base::~Base" << endl;
    }
};

输出结果：

Derived::~Derived
Base::~Base

5.2 坑点 2：重写虚函数时签名不一致，导致多态失效

问题现象：派生类函数名、参数列表或返回值与基类虚函数不一致，误以为重写成功，实际未重写，多态失效。

错误代码：

class Base {
public:
    virtual void func(int a) {  // 参数为int
        cout << "Base::func(" << a << ")" << endl;
    }
};

class Derived : public Base {
public:
    // 错误：参数为double，与基类不一致，未重写
    void func(double a) {
        cout << "Derived::func(" << a << ")" << endl;
    }
};

int main() {
    Base* p = new Derived();
    p->func(10);  // 调用Base::func，多态失效
    delete p;
    return 0;
}

解决方案：使用override关键字显式声明重写，编译器会检查签名是否一致。

class Derived : public Base {
public:
    // 编译器报错：没有找到基类中可重写的虚函数
    void func(double a) override {
        cout << "Derived::func(" << a << ")" << endl;
    }
};

5.3 坑点 3：纯虚函数未实现，导致抽象类无法实例化

问题现象：包含纯虚函数的类是抽象类，无法直接实例化，若派生类未实现纯虚函数，派生类也会成为抽象类。

错误代码：

class Base {
public:
    virtual void func() = 0;  // 纯虚函数
};

class Derived : public Base {
    // 未实现func()，Derived是抽象类
};

int main() {
    Derived d;  // 编译器报错：Derived是抽象类，无法实例化
    return 0;
}

解决方案：派生类必须实现基类的所有纯虚函数。

class Derived : public Base {
public:
    void func() override {
        cout << "Derived::func" << endl;
    }
};

5.4 坑点 4：构造函数 / 析构函数中调用虚函数，多态失效

问题现象：构造函数和析构函数中调用虚函数，不会触发动态多态，只会调用当前类的虚函数实现。

代码示例：

class Base {
public:
    Base() {
        cout << "Base::Base" << endl;
        func();  // 构造函数中调用虚函数
    }
    virtual void func() {
        cout << "Base::func" << endl;
    }
    virtual ~Base() {
        cout << "Base::~Base" << endl;
        func();  // 析构函数中调用虚函数
    }
};

class Derived : public Base {
public:
    Derived() {
        cout << "Derived::Derived" << endl;
        func();
    }
    void func() override {
        cout << "Derived::func" << endl;
    }
    ~Derived() {
        cout << "Derived::~Derived" << endl;
        func();
    }
};

int main() {
    Derived d;
    return 0;
}

输出结果：

Base::Base
Base::func  // 基类构造中调用Base::func
Derived::Derived
Derived::func  // 派生类构造中调用Derived::func
Derived::~Derived
Derived::func  // 派生类析构中调用Derived::func
Base::~Base
Base::func  // 基类析构中调用Base::func

原因：

构造基类时，派生类尚未初始化，虚指针指向基类的虚函数表；
析构基类时，派生类已析构，虚指针已切换回基类的虚函数表。

六、性能优化：多态的开销与优化技巧

动态多态虽然灵活，但存在一定的性能开销，在对性能敏感的场景（如高频调用的核心模块）需要优化。

6.1 多态的性能开销来源

虚函数调用开销：需要通过虚指针查找虚函数表，比普通函数调用多 1-2 个内存访问操作；
虚指针占用内存：每个包含虚函数的对象都会多一个指针大小的内存开销（32 位系统 4 字节，64 位系统 8 字节）；
编译优化受限：编译器无法对虚函数调用进行内联优化（因为运行时才确定调用哪个函数）。

6.2 优化技巧

6.2.1 优先使用静态多态（模板）

对于性能敏感且类型固定的场景，用模板替代虚函数，避免动态多态的开销。

优化示例：

// 静态多态（模板），无运行时开销
template <typename T>
void animalCry(T& animal) {
    animal.makeSound();  // 编译时确定调用哪个函数，可内联优化
}

// 动态多态（虚函数），有运行时开销
void animalCryDynamic(Animal& animal) {
    animal.makeSound();  // 运行时查找虚函数表
}

6.2.2 减少虚函数数量

只将需要重写的函数设为虚函数，避免不必要的虚函数增加开销。

6.2.3 使用 CRTP 静态多态（奇异递归模板模式）

CRTP 是一种高级技巧，通过模板实现静态多态，兼具动态多态的灵活性和静态多态的性能。

CRTP 示例：

#include <iostream>
using namespace std;

// 基类模板，派生类作为模板参数
template <typename Derived>
class Base {
public:
    void func() {
        // 静态_cast将this转为派生类指针，调用派生类的实现
        static_cast<Derived*>(this)->implFunc();
    }
};

// 派生类继承基类模板，传入自身作为参数
class Derived1 : public Base<Derived1> {
public:
    void implFunc() {
        cout << "Derived1::implFunc" << endl;
    }
};

class Derived2 : public Base<Derived2> {
public:
    void implFunc() {
        cout << "Derived2::implFunc" << endl;
    }
};

int main() {
    Derived1 d1;
    d1.func();  // 输出“Derived1::implFunc”

    Derived2 d2;
    d2.func();  // 输出“Derived2::implFunc”

    return 0;
}

优势：无虚函数表和虚指针开销，编译时确定调用逻辑，性能接近普通函数调用。