C++构造函数调用虚函数问题：栈对象如何实现构造后回调？

你的核心问题是：基类构造函数中调用纯虚函数AtCreate()会触发未定义行为——派生类对象尚未完成构造，虚函数表还未切换到派生类版本，此时调用的AtCreate()实际是基类的纯虚函数（直接崩溃），即便不是纯虚函数，也无法访问派生类构造中初始化的成员。而栈对象无法通过重载operator new的方式在构造完成后触发回调，需要一种通用的自动回调策略。

以下是几种可行的实现方式：

方案1：包装类（推荐，完全自动适配栈对象） #

通过一个模板包装类，在包装类的构造函数中等待被包装对象完全构造后调用AtCreate()，在包装类析构时先调用析构前回调AtDestroy()，再执行对象的析构。

步骤1：修正基类定义（移除构造函数中的AtCreate()调用） #

#include <utility> // 用于std::forward

class basic 
{
protected:
    basic() = default; // 基类仅负责初始化自身成员，不调用回调
public:
    virtual void AtCreate() = 0;      // 构造后回调
    virtual void AtDestroy() = 0;     // 析构前回调
    virtual ~basic() = default;       // 必须声明虚析构，确保派生类析构被正确调用
};

class A : public basic 
{
public:
    A() = default;
    void AtCreate() override { /* 派生类构造完成后执行的逻辑 */ }
    void AtDestroy() override { /* 派生类析构前执行的逻辑 */ }
};

class B : public A 
{
public:
    B() = default;
    void AtCreate() override { /* 派生类构造完成后执行的逻辑 */ }
    void AtDestroy() override { /* 派生类析构前执行的逻辑 */ }
};

步骤2：实现模板包装类 #

template<typename T>
class ObjectWrapper
{
public:
    // 默认构造版本
    ObjectWrapper() : obj_()
    {
        obj_.AtCreate(); // 此时T的所有基类+自身构造均已完成
    }

    // 支持带参数的构造函数（完美转发参数）
    template<typename... Args>
    explicit ObjectWrapper(Args&&... args) : obj_(std::forward<Args>(args)...)
    {
        obj_.AtCreate();
    }

    // 析构时先调用回调，再销毁对象
    ~ObjectWrapper()
    {
        obj_.AtDestroy();
    }

    // 重载运算符，让包装类可以像原对象一样使用
    T* operator->() noexcept { return &obj_; }
    const T* operator->() const noexcept { return &obj_; }
    T& operator*() noexcept { return obj_; }
    const T& operator*() const noexcept { return obj_; }

    // 直接获取原对象的引用
    T& get() noexcept { return obj_; }
    const T& get() const noexcept { return obj_; }

private:
    T obj_; // 栈上存储原对象
};

使用方式 #

// 栈上创建B类型对象，自动触发AtCreate()
ObjectWrapper<B> b_obj;
b_obj->some_member_function(); // 像普通对象一样访问成员

// 带参数的构造示例
ObjectWrapper<A> a_obj(/* A的构造参数 */);

// 离开作用域时，自动先调用b_obj.obj_.AtDestroy()，再析构B对象

这个方案的优势：

• 完全兼容栈对象，无需动态分配内存
• 自动触发回调，不需要修改派生类的构造/析构逻辑
• 通过运算符重载，包装类的使用方式和原对象几乎一致

方案2：CRTP（奇异递归模板模式） #

利用模板特性让基类感知派生类类型，在派生类构造完成后主动触发回调。需要派生类在构造函数末尾显式调用触发函数。

template<typename Derived>
class basic_crtp
{
protected:
    basic_crtp() = default;

public:
    void trigger_post_create()
    {
        static_cast<Derived*>(this)->AtCreate();
    }

    virtual void AtCreate() = 0;
    virtual void AtDestroy() = 0;
    virtual ~basic_crtp()
    {
        static_cast<Derived*>(this)->AtDestroy();
    }
};

class A : public basic_crtp<A>
{
public:
    A() : basic_crtp<A>()
    {
        // 派生类构造完成后，主动触发回调
        trigger_post_create();
    }

    void AtCreate() override { /* 构造后逻辑 */ }
    void AtDestroy() override { /* 析构前逻辑 */ }
};

使用方式：直接声明栈对象即可，派生类构造会自动触发回调：

A a_obj; // 构造完成后自动调用AtCreate()

为什么线程池方案不可行？ #

线程池的任务是异步执行的，无法保证在对象构造完成后立刻执行AtCreate()；如果是栈对象，线程池任务还未执行完毕，对象可能已经离开作用域被销毁，导致回调函数访问已释放的内存，引发未定义行为。

内容的提问来源于stack exchange，提问作者blueperfect