动态选择派生类实例化时如何妥善管理内存？

原代码结构 #

struct Base {
    virtual void f() = 0;
    virtual ~Base() {};
};
struct Helper: Base {
    virtual void f() {}
};
struct Derived: public Base {
    Derived(Helper& helper): m_helper(helper) {}
    void f() {}
    Helper& m_helper;
};

原有实现与需求 #

原代码通过预处理器条件编译实现实例化选择：

Helper h;
#if condition
    Derived d(h);
#else
    Helper& d(h);
#endif

现在需要动态条件实例化（根据运行时条件判断），同时要求：

• 保留Helper实例（因为Derived持有其引用）
• 尽可能降低内存泄漏、空引用等出错概率

尝试方案的问题 #

1. 直接替换std::unique_ptr<Base>会销毁原Helper实例：

std::unique_ptr<Base> p = new Helper();
if(condition){
    p = new Derived(*helper); // 此处会删除原Helper对象，不符合需求
}

2. std::optional<Derived>方案存在语法错误：

Helper h;
std::optional<Derived> d = condition ? Derived(h) : {};
Base& p = d ? d : h; // 编译错误：类型不匹配

3. 手动管理指针易引发内存泄漏：

Helper h;
Derived* d = condition ? new Derived(h) : 0;
Base& p = d ? *d : h;
// ...业务逻辑
if(d) delete d; // 需手动释放，遗忘则泄漏

推荐实现方式 #

方案1：使用std::variant（C++17及以上） #

类型安全且无需手动管理内存，完美适配两种类型的切换：

#include <variant>
#include <functional>

Helper h;
std::variant<Helper&, Derived> obj = condition 
    ? std::variant<Helper&, Derived>(Derived(h)) 
    : std::variant<Helper&, Derived>(std::ref(h));

// 使用时通过std::visit访问
std::visit([](Base& base) {
    base.f(); // 调用对应类型的f()
}, obj);

• 优势：自动管理Derived的生命周期，类型安全，无空指针/引用风险
• 注意：Helper的生命周期需长于obj，避免悬垂引用

方案2：拆分智能指针与引用（兼容C++11及以上） #

让智能指针仅管理Derived的内存，Base&始终指向有效实例：

#include <memory>

Helper h;
std::unique_ptr<Derived> derived_ptr;
Base& p = condition 
    ? (derived_ptr = std::make_unique<Derived>(h), *derived_ptr) 
    : static_cast<Base&>(h);

// 直接使用引用调用方法
p.f();
// derived_ptr会自动释放Derived内存，无需手动操作

• 优势：简洁直观，无手动内存管理负担，兼容性好

方案3：封装辅助函数（兼容C++11及以上） #

将实例化逻辑封装，简化外部调用：

#include <memory>

Base& get_instance(Helper& h, bool condition) {
    static std::unique_ptr<Derived> derived;
    if(condition) {
        derived.reset(new Derived(h));
        return *derived;
    } else {
        derived.reset(); // 释放已存在的Derived
        return h;
    }
}

// 使用方式
Helper h;
Base& p = get_instance(h, condition);
p.f();

• 优势：逻辑封装后调用简单，旧标准兼容
• 注意：多线程场景需添加同步机制避免竞态

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