Item 9：绝不在构造和析构期间调用 virtual 函数

从“派生对象尚未成为派生对象”开始

class Transaction {
public:
    explicit Transaction(const LogInfo& info)
    {
        logTransaction(info); // virtual
    }
    virtual void logTransaction(const LogInfo&) const = 0;
};
 
class BuyTransaction : public Transaction {
public:
    BuyTransaction() : Transaction{createLogInfo()} {}
    void logTransaction(const LogInfo&) const override;
};

执行 Transaction constructor 时，BuyTransaction 自己的成员和不变量还没有建立。若 virtual dispatch 进入 BuyTransaction override，它可能读取尚未开始生命周期的数据。

在 base constructor 中被视为 Base，在 Derived constructor 完成相应层后才成为完整 Derived。

构造/析构期间受到生命周期阶段限制。 Never call virtual functions during construction or destruction（绝不在构造和析构期间调用 virtual 函数）同时覆盖直接调用和隐藏在 helper、NVI、callback 内的间接路径。

为什么语言要限制 dispatch

Base subobject 必须先构造，Derived members 随后才初始化。反向析构时 Derived members 先消失，Base destructor 最后运行。

construct: virtual bases -> direct bases -> members -> derived body
destroy:   derived body -> members -> direct bases -> virtual bases

只有此时 virtual 调用才能安全依赖最派生状态。限制 dispatch 是保护未构造/已销毁 subobject，不是功能缺陷。

Base constructor 中 virtual 只到 Base

class Base {
public:
    Base() { announce(); }
    virtual ~Base() = default;
private:
    virtual void announce() const { std::puts("Base"); }
};
 
class Derived : public Base {
private:
    void announce() const override { std::puts("Derived"); }
};

构造 Derived 时，Base constructor 调用 Base::announce，不会调用 Derived::announce。

如果 Base 版本是 pure virtual 且没有可调用定义，直接或间接调用可能产生 pure virtual call、链接错误或未定义行为。

编译器对直接调用有时能警告，但间接路径更隐蔽。

间接调用同样危险

class Transaction {
public:
    Transaction() { initialize(); }
private:
    void initialize()
    {
        validateBaseState();
        logTransaction(); // virtual，仍处于 Base constructor
    }
    virtual void logTransaction() const = 0;
};

代码审查若只搜索 constructor 体中的 virtualName() 会漏掉 helper、lambda、callback 和注册表调用。

注册 observer、启动线程、把 this 放进全局容器都可能造成更严重的提前调用。

NVI 不会绕开生命周期规则

在正常生命周期中可集中不变量检查；但 Base constructor 调 public NVI，内部 virtual hook 仍只到 Base 层。

void Base::initializeInterface()
{
    checkBasePrecondition();
    doInitialize(); // virtual，构造期间仍受限
}

模式不能改变对象生命周期。不要用额外非虚包装掩盖时机错误。

析构阶段动态能力反向收缩

class Base {
public:
    virtual ~Base() { audit(); }
private:
    virtual void audit() const { /* Base state only */ }
};

Base destructor 中 audit 不会进入 Derived override，因为 Derived destructor 和成员已经结束。

每一层 destructor 应清理该层自己拥有的资源；不要让 Base 要求 Derived 回调帮它收尾。

替代一：派生先计算数据再传给 Base

若 Base constructor 只是想记录派生类型相关信息，让 Derived 以 static helper 计算参数：

class Transaction {
protected:
    explicit Transaction(LogInfo info)
        : info_{std::move(info)}
    {
        logTransaction(info_); // non-virtual Base implementation
    }
private:
    void logTransaction(const LogInfo&) const;
    LogInfo info_;
};
 
class BuyTransaction : public Transaction {
public:
    BuyTransaction()
        : Transaction{createLogInfo()} {}
private:
    static LogInfo createLogInfo();
};

static helper 没有 this，不能误读未初始化成员。Base 获得完整值后使用非虚逻辑。

适合参数可在构造前确定的场景。

替代二：完整构造后显式 start

某些初始化确实需要最派生行为，例如注册插件能力或调用虚拟设备。用 factory 保证构造后再启动：

class Component {
public:
    virtual ~Component() = default;
    void start()
    {
        if (state_ != State::Constructed)
            throw std::logic_error{"invalid start state"};
        doStart();
        state_ = State::Started;
    }
private:
    virtual void doStart() = 0;
    State state_{State::Constructed};
};
 
template<class T, class... Args>
std::unique_ptr<T> makeStarted(Args&&... args)
{
    auto candidate = std::make_unique<T>(std::forward<Args>(args)...);
    candidate->start();
    return candidate;
}

start 失败时 candidate unique_ptr 自动销毁完整对象，不发布半启动实例。

防止调用方忘记 start，应隐藏 public constructor 或只暴露 factory。

两阶段初始化的状态成本

post-construction 不是免费方案：所有 public 操作必须拒绝未 Started 状态；重复 start、并发 start、start 失败重试要有协议。

enum class State { Constructed, Starting, Started, Failed, Stopped };

优先让 start 在局部构建候选资源，成功后一次提交；外部注册尽量最后发生。析构按当前 state 只清理已拥有部分且不抛异常。

callback 注册必须晚于完整构造

constructor 中注册会发生 this escape。即使事件源承诺“稍后”，并发线程也可能立即回调。

void Sensor::doStart()
{
    auto token = eventLoop_.subscribe([this](Event e) {
        onEvent(e); // 此时对象已完整构造且 Started 提交需有顺序
    });
    subscription_ = std::move(token);
}

并发系统还需同步；单纯“移出 constructor”不自动解决 data race。

审计直接与隐藏路径

编译器警告如 -Wvirtual-call/静态分析可辅助，但需要人工追踪非虚 helper 和 this escape。

先预测：Base constructor 调 helper，helper 调 pure virtual；Derived override 依赖 member flag。写出每层对象生命周期、实际 dispatch 与可能诊断，再运行日志 probe。

• Base/Derived 每层 constructor/destructor 记录当前成员 ready 标志。
• 任何 virtual override 断言其层级 ready，构造/析构测试不得触发。
• factory start 前所有成员已初始化，start 失败对象未发布。
• callback 只在 Started 后可见，stop 后先注销再销毁成员。
• direct、helper、lambda 与 NVI 调用链均在静态审计清单中。
• sanitizer 和线程测试覆盖 this escape 与 start/stop 竞争。

小结

• 构造时 dynamic type 逐层扩展，析构时逐层收缩
• Base constructor/destructor 中 virtual 调用不会进入尚未构造或已销毁的 Derived
• helper、NVI、callback 与 this escape 都可能隐藏生命周期内 virtual 调用
• 可提前计算的派生信息作为普通构造参数传给 Base
• 必须使用最派生行为时，由 factory 在完整构造后执行 start，并失败不发布
• 两阶段初始化需要状态机、rollback 与 callback publication 协议