C++ 虚函数与纯虚函数：深入理解多态机制

运行结果会显示各自派生类的实现：

汽车在公路上飞驰
飞机在蓝天上翱翔

注意：建议使用 override 关键字显式声明重写。如果函数签名不匹配，编译器会直接报错，这能有效防止意外覆盖或遗漏。

另外，虚函数不能是 static 静态函数，因为静态函数属于类本身，不属于具体对象，无法实现运行时绑定。

二、纯虚函数与抽象类

纯虚函数是没有函数体的虚函数，通常用于定义接口规范。包含纯虚函数的类称为抽象类，它不能被实例化，只能作为基类被继承。

2.1 声明语法

在虚函数声明末尾添加 = 0：

class AbstractBase {
public:
    virtual void interfaceFunc() = 0;
};

2.2 核心特性

• 无法实例化：不能直接创建抽象类的对象，只能定义指针或引用。
• 强制重写：派生类必须重写所有纯虚函数，否则派生类也会成为抽象类。
• 接口作用：抽象类只定义接口，具体功能由派生类实现。

2.3 实战案例：图形绘制系统

这是一个典型的抽象类应用场景，定义了图形的通用接口，由具体形状类实现细节：

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

// 抽象类：图形
class Shape {
public:
    string color;
    
    // 纯虚函数：绘制图形
    virtual void draw() = 0;
    
    // 纯虚函数：计算面积
    virtual double getArea() = 0;
    
    // 普通成员函数：设置颜色
    void setColor(string c) {
        color = c;
    }
};

// 派生类：三角形
class Triangle : public Shape {
private:
    double base;
    double height;
public:
    Triangle(double b, double h) : base(b), height(h) {}

    void draw() override {
        cout << "绘制一个" << color << "的三角形" << endl;
    }
    
    double getArea() override {
        return 0.5 * base * height;
    }
};

// 派生类：正方形
class Square : public Shape {
private:
    double side;
public:
    Square(double s) : side(s) {}

    void draw() override {
        cout << "绘制一个" << color << "的正方形" << endl;
    }
    
    double getArea() override {
        return side * side;
    }
};

int main() {
    // 抽象类不能实例化对象
    // Shape s; // 编译错误

    // 抽象类指针指向派生类对象
    Shape* shape1 = new Triangle(10, 5);
    Shape* shape2 = new Square(8);

    shape1->setColor("红色");
    shape2->setColor("蓝色");

    shape1->draw();
    cout << "三角形面积：" << shape1->getArea() << endl;
    
    shape2->draw();
    cout << "正方形面积：" << shape2->getArea() << endl;

    delete shape1;
    delete shape2;
    return 0;
}

运行结果：

绘制一个红色的三角形
三角形面积：25
绘制一个蓝色的正方形
正方形面积：64

三、虚函数与纯虚函数的核心区别

四、虚函数表的底层工作机制

C++ 动态多态的底层依赖虚函数表（vtable）和虚函数指针（vptr）。理解这一点有助于规避开发中的隐藏陷阱。

4.1 基本概念

• 虚函数表（vtable）：编译器为每个包含虚函数的类生成一个全局表，存储该类所有虚函数的地址。
• 虚函数指针（vptr）：每个对象内存布局中包含一个隐藏的指针，指向所属类的虚函数表。
• 继承与重写：派生类的虚函数表继承自基类。若重写虚函数，新地址会覆盖表中对应位置。

4.2 工作流程

1. 编译时，为每个含虚函数的类生成虚函数表。
2. 创建对象时，自动添加 vptr 并指向所属类的虚函数表。
3. 运行时，通过基类指针调用虚函数，先通过 vptr 找到虚函数表。
4. 根据表中地址调用对应类的函数版本。

4.3 内存布局示例

以 Vehicle 基类和 Car 派生类为例：

• Vehicle 类的虚函数表：&Vehicle::run
• Car 类的虚函数表：&Car::run（覆盖基类地址）

当 Vehicle* v = new Car() 时，v 指向对象的 vptr 会指向 Car 类的虚函数表，调用 v->run() 时执行 Car::run。

关键点：虚函数表属于类，所有对象共享；虚函数指针属于对象，每个对象独立占用 4 字节（32 位）或 8 字节（64 位）。

五、虚析构函数：解决资源泄漏问题

当基类指针指向派生类对象并通过 delete 释放时，如果基类析构函数不是虚函数，派生类的析构函数将不会被调用，导致内存泄漏。

5.1 问题演示（非虚析构函数）

#include <iostream>
using namespace std;

class Base {
public:
    Base() { cout << "Base 构造函数被调用" << endl; }
    ~Base() { cout << "Base 析构函数被调用" << endl; } // 非虚析构
};

class Derived : public Base {
private:
    int* data;
public:
    Derived() { data = new int[10]; cout << "Derived 构造函数被调用" << endl; }
    ~Derived() { delete[] data; cout << "Derived 析构函数被调用" << endl; }
};

int main() {
    Base* p = new Derived();
    delete p; // 仅调用基类析构函数
    return 0;
}

运行结果只显示了 Base 的析构，Derived 中的 data 数组未被释放。

5.2 解决方案：虚析构函数

将基类析构函数声明为 virtual：

#include <iostream>
using namespace std;

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

class Derived : public Base {
private:
    int* data;
public:
    Derived() { data = new int[10]; cout << "Derived 构造函数被调用" << endl; }
    ~Derived() override { delete[] data; cout << "Derived 析构函数被调用" << endl; }
};

int main() {
    Base* p = new Derived();
    delete p; // 先调用派生类析构，再调用基类析构
    return 0;
}

此时输出顺序变为 Derived 析构在前，Base 析构在后，资源得到正确释放。

✅ 开发规范：只要类中包含虚函数，就应该将析构函数声明为虚析构函数。

六、虚函数的常见陷阱与解决方案

1. 函数签名不匹配：派生类函数与基类虚函数签名不一致会导致无法触发多态。务必使用 override 关键字检测合法性。
2. 构造函数/析构函数中调用虚函数：此时对象类型尚未完全构建或正在销毁，虚函数调用不会发生多态。避免在此处调用虚函数。
3. 性能开销：虚函数调用涉及间接寻址，比普通函数慢。在高性能场景下，可考虑模板等静态多态方式替代。

七、实战案例：员工薪资计算系统

设计一个支持不同角色薪资计算的系统，利用虚函数实现扩展性。

7.1 需求分析

• 抽象基类 Employee：包含纯虚函数 calculateSalary。
• 派生类 RegularEmployee：普通员工，薪资 = 基本工资。
• 派生类 TechEmployee：技术员工，薪资 = 基本工资 + 技术补贴。
• 派生类 Manager：管理人员，薪资 = 基本工资 + 管理补贴。

7.2 代码实现

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

// 抽象基类：员工
class Employee {
protected:
    string name;
    double baseSalary;
public:
    Employee(string n, double bs) : name(n), baseSalary(bs) {}

    virtual double calculateSalary() = 0;
    virtual ~Employee() {}

    string getName() { return name; }
};

// 派生类：普通员工
class RegularEmployee : public Employee {
public:
    RegularEmployee(string n, double bs) : Employee(n, bs) {}
    double calculateSalary() override {
        return baseSalary;
    }
};

// 派生类：技术员工
class TechEmployee : public Employee {
private:
    double techAllowance;
public:
    TechEmployee(string n, double bs, double ta) : Employee(n, bs), techAllowance(ta) {}
    double calculateSalary() override {
        return baseSalary + techAllowance;
    }
};

// 派生类：管理人员
class Manager : public Employee {
private:
    double manageAllowance;
public:
    Manager(string n, double bs, double ma) : Employee(n, bs), manageAllowance(ma) {}
    double calculateSalary() override {
        return baseSalary + manageAllowance;
    }
};

void printSalary(Employee* emp) {
    cout << "员工 " << emp->getName() << " 的薪资为：" << emp->calculateSalary() << " 元" << endl;
}

int main() {
    Employee* emp1 = new RegularEmployee("张三", 5000);
    Employee* emp2 = new TechEmployee("李四", 6000, 2000);
    Employee* emp3 = new Manager("王五", 8000, 3000);

    printSalary(emp1);
    printSalary(emp2);
    printSalary(emp3);

    delete emp1;
    delete emp2;
    delete emp3;
    return 0;
}

运行结果：

员工 张三 的薪资为：5000 元
员工 李四 的薪资为：8000 元
员工 王五 的薪资为：11000 元

八、总结

虚函数通过 virtual 关键字声明，支持派生类重写，实现运行时多态；纯虚函数无函数体，用于定义接口，使类成为抽象类。底层依赖虚函数表和虚指针完成动态分发。虚析构函数是防止内存泄漏的关键，凡是有虚函数的类都应声明虚析构。掌握这些机制，配合开闭原则，能显著提升大型 C++ 项目的可维护性与扩展性。