C++ 虚函数与纯虚函数：从接口设计到虚析构陷阱

输出：

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

虚函数不能是 static，因为 static 方法不绑定对象，多态没法工作。

纯虚函数：定义接口

很多场景下基类方法压根不需要默认实现，只是想让派生类必须实现它。这时候就用纯虚函数，在声明后面加 = 0。

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

含有纯虚函数的类就是抽象类，不能直接实例化对象。这适合用来做接口。比如一个图形绘制系统，所有形状都得有 draw 和 getArea 方法：

#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

虚函数 vs 纯虚函数

实际使用中区别很直白：

• 虚函数有默认实现，基类可以被实例化；派生类可以选择重写，也可以直接用基类的。
• 纯虚函数只声明接口，基类变成抽象类，派生类必须实现所有纯虚函数，否则自己也是抽象类。
• 通常虚函数给'可能被改写'的默认行为，纯虚函数用来强制子类实现契约。

虚函数表：多态的底层

C++ 实现运行时多态靠的是虚函数表（vtable）和虚函数指针（vptr）。每个含有虚函数的类，编译器会为其生成一个虚函数表，里面存着这个类所有虚函数的实际地址。每个对象内存中有一个隐藏指针 vptr，指向自己类的虚函数表。

当通过基类指针调用虚函数时，实际步骤是：通过对象的 vptr 找到虚函数表，再从表里找到对应函数地址并调用。重写了虚函数的派生类，会将基类的函数地址在表中替换成自己的。

上例中 Vehicle 和 Car 的虚函数表里，run 的地址不同。Vehicle* v = new Car(); 时对象的 vptr 指向 Car 的虚函数表，因此 v->run() 最终调用的是 Car::run。

虚函数表是类级别的，所有对象共享；vptr 在每个对象里单独占一个指针大小（64位系统8字节）。

虚析构函数：一个容易忘记的坑

当你用基类指针 delete 派生类对象时，如果基类析构函数不是虚函数，那么只会调用基类的析构函数，派生类部分不会被析构。如果你的派生类里有动态分配的资源，直接泄漏。

看这个错误示范：

#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; // 只调了 Base 析构
    return 0;
}

输出：

Base 构造函数被调用
Derived 构造函数被调用
Base 析构函数被调用

派生类的 data 数组根本没被释放。

解决办法就是把基类析构函数改成 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;
}

输出：

Base 构造函数被调用
Derived 构造函数被调用
Derived 析构函数被调用
Base 析构函数被调用

我写项目时有个习惯：只要一个类里有虚函数，立刻把析构函数也带上 virtual，哪怕暂时没有派生类，也能防止以后别人继承时踩坑。

其他容易踩的坑

1. 函数签名不一致。派生类里的函数和基类虚函数名字一样但参数不同，或者少了 const，都不会触发多态，而且不报错。所以写 override。
2. 在构造函数或析构函数里调虚函数。这时候对象的类型还不是派生类（构造时），或者已经退化（析构时），多态不会发生。尽量避免这种写法，或者把逻辑提取到非构造/析构的成员函数里。
3. 性能。虚函数调用比普通函数多一层间接寻址，开销虽小但密集循环里可能明显。如果不需要运行时多态，可以改用模板或其他静态机制。

一个薪资计算例子

把虚函数用在业务上：不同角色员工薪资算法不同，但外部统一通过 Employee 接口计算。

#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 元

设计时把抽象基类的析构函数写成了虚析构（虽然这里没动态分配，但防患未然）。新增员工类型只需要继承 Employee 并实现 calculateSalary，不用改打印逻辑，符合开闭原则。

这些内容把虚函数、纯虚函数的核心用途和常见坑都覆盖了，实际编码时多留意 override 和虚析构，多态就能用得很顺手。