虚函数

是什么，为什么存在

虚函数（virtual function） 是基类声明为 virtual 的非静态成员函数。派生类可以提供与它匹配的重写实现；代码通过基类引用或指针调用时，运行时会根据完整对象的动态类型选择函数体。

这解决了「调用者只知道共同接口，但行为取决于实际对象」的问题。例如，告警系统可以保存不同的 AlertSink，只调用统一的 send()，而不必让中央分支列出控制台、文件和网络等每一种具体类型。

这种能力叫作 子类型多态（subtype polymorphism） 。静态类型决定哪些成员可见以及哪些重载参与解析；动态类型只在已经选中虚函数后决定执行哪个最终覆盖函数。把这两个阶段混成一个，是许多重写错误的根源。

只有确实需要运行时替换行为时才应引入虚函数。对象集合需要容纳调用方事先不知道的实现，或库向使用方开放扩展点时，它很合适；类型集合封闭且编译期已知时，std::variant、模板或普通组合有时能把约束表达得更清楚。

虚函数不会自动赋予接口正确的所有权、生命周期或替换语义。基类仍需定义输入、结果、错误和析构契约，派生类也必须保持这些契约。能成功分派只说明语言找到了函数体，不说明这个层次设计合理。

工作原理

表达式的静态类型来自声明和类型推导，完整对象的动态类型则是对象实际构造出的最派生类型。若 JsonFormatter 对象绑定到 const Formatter&，引用的静态类型是 Formatter，对象的动态类型仍是 JsonFormatter。

编译器先执行名字查找与重载决议。若选中的成员不是虚函数，调用在这个阶段已经确定；若它是虚函数，而且调用没有被显式限定，运行时再从动态类型找到 最终覆盖函数（final overrider） 。

基类只需在首次声明处写 virtual，虚属性会沿派生链保留。派生类最好写 override，让编译器验证形参、const、引用限定符和返回类型等规则；final 则禁止更深层派生类再次重写该函数，也可以放在类声明上禁止继续派生。

把函数声明为 纯虚函数（pure virtual function） 时，在声明末尾写 = 0。含有尚未得到具体最终覆盖函数的纯虚函数的类是 抽象类（abstract class） ，不能直接实例化；派生类只有补全所有纯虚操作后才能成为具体类。

虚分派保留的是动态类型，不是被切掉的数据。把派生对象复制进基类值会产生 对象切片（object slicing） ：新对象只有基类子对象，其动态类型就是基类。之后再调用虚函数也无法恢复已经丢失的派生部分。

若接口允许通过基类指针拥有并删除派生对象，基类需要公有 虚析构函数（virtual destructor） 。这样销毁会先进入最派生类析构函数，再按顺序销毁基类部分；公有非虚析构会让这种删除产生 未定义行为（undefined behavior） 。

示例

下面三个程序依次展示虚分派、抽象接口的多态所有权，以及构造与析构期间受限的分派。它们都使用本地 GCC 13.3，以 -std=c++23 -Wall -Wextra -Wpedantic -Werror 编译并执行；输出是实际运行结果。

动态成员与静态成员

render() 是虚函数，category() 不是。print_order() 只接收 Formatter 引用，因此两个成员在同一调用点表现不同。

formatter.category() 在 main() 中按表达式的静态类型 JsonFormatter 选择函数，所以输出 json。进入 print_order() 后，非虚 category() 按静态类型 Formatter 选择，输出 formatter。

render() 的重载决议同样从 Formatter 接口开始，但它是虚函数。对象的动态类型是 JsonFormatter，因此最终执行带有 override 的实现，输出 JSON 文本。

纯虚接口与多态所有权

AlertSink 只规定行为，不提供 send() 的默认实现。容器通过 std::unique_ptr<AlertSink> 拥有不同的具体对象，因此基类析构函数必须是公有虚函数。

#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>

class AlertSink {
public:
    virtual void send(const std::string& message) = 0;
    virtual ~AlertSink() = default;
};

class ConsoleSink final : public AlertSink {
public:
    explicit ConsoleSink(std::string prefix) : prefix_(std::move(prefix)) {}

    void send(const std::string& message) override {
        std::cout << prefix_ << message << '\n';
    }

private:
    std::string prefix_;
};

class CountingSink final : public AlertSink {
public:
    void send(const std::string& message) override {
        std::cout << "count=" << ++count_ << " message=" << message << '\n';
    }

private:
    int count_ = 0;
};

int main() {
    std::vector<std::unique_ptr<AlertSink>> sinks;
    sinks.push_back(std::make_unique<ConsoleSink>("[ops] "));
    sinks.push_back(std::make_unique<CountingSink>());

    for (const auto& sink : sinks) {
        sink->send("disk 95%");
    }
}

[ops] disk 95%
count=1 message=disk 95%

容器元素的静态接口都是 AlertSink，每个指针所指对象的动态类型却不同。循环不需要 if 或类型转换，两个 send() 调用各自进入正确的最终覆盖函数。

离开 main() 时，unique_ptr<AlertSink> 通过基类指针删除对象。虚析构保证 ConsoleSink 或 CountingSink 的析构过程先发生，再销毁 AlertSink 部分；即使当前派生类没有手写析构函数，这仍是接口必须写明的所有权契约。

构造与析构期间的分派

构造或析构某一层基类时，虚调用不会进入更派生、尚未开始或已经结束生命周期的部分。下面的 Stage 构造函数和析构函数都调用 report()，但两次都只会进入 Stage::report()。

#include <iostream>

class Stage {
public:
    Stage() {
        std::cout << "Stage ctor: ";
        report();
    }

    virtual void report() const {
        std::cout << "Stage::report\n";
    }

    virtual ~Stage() {
        std::cout << "Stage dtor: ";
        report();
    }
};

class Pipeline final : public Stage {
public:
    Pipeline() {
        std::cout << "Pipeline ctor: ";
        report();
    }

    void report() const override {
        std::cout << "Pipeline::report ready=" << std::boolalpha << ready_ << '\n';
    }

    ~Pipeline() override {
        std::cout << "Pipeline dtor: ";
        report();
    }

private:
    bool ready_ = true;
};

int main() {
    Pipeline pipeline;
    std::cout << "main: ";
    pipeline.report();
}

Stage ctor: Stage::report
Pipeline ctor: Pipeline::report ready=true
main: Pipeline::report ready=true
Pipeline dtor: Pipeline::report ready=true
Stage dtor: Stage::report

执行 Stage 构造函数时，Pipeline 部分尚未开始生命周期，所以首行不能读取 ready_。进入 Pipeline 构造函数体后，成员已经初始化，调用才会到达 Pipeline::report()。

析构顺序相反。Pipeline 析构函数体运行时派生部分仍然存在；进入 Stage 析构函数后，派生部分的生命周期已经结束，分派便停在 Stage。

陷阱

看似重写，实际新增重载

修复方法： 每个派生实现都写 override，并把编译失败当作接口不匹配的证据。核对形参类型、const、引用限定符和协变返回类型，不要靠重复书写 virtual 表达意图。

经基类所有，却使用非虚析构

修复方法： 允许多态删除时使用公有虚析构函数。若设计明确禁止通过基类删除，则使用受保护非虚析构函数，并让所有权接口返回能表达真实删除方式的类型。

在值边界发生对象切片

修复方法： 非拥有调用使用 Base& 或 const Base&，异构所有权通常使用 std::unique_ptr<Base>。确实需要多态值语义时，应明确设计 clone() 契约或选择封闭的 std::variant 表示。

依赖构造函数调用派生实现

修复方法： 构造函数只建立当前类能独立保证的不变量。需要完整对象后的可替换步骤时，使用工厂在构造结束后调用，或把所需数据作为普通构造参数交给基类。

混用虚函数与不同默认实参

修复方法： 虚函数不要在派生层改变默认实参。把默认值放进基类的非虚入口，再由它调用不带默认实参的虚核心，或要求调用方始终显式传值。

延伸阅读

• C++ 工作草案：虚函数
• C++ 工作草案：抽象类
• C++ 工作草案：析构函数
• C++ 工作草案：构造与析构
• C++ Core Guidelines：C.128 虚函数声明