如何根据构造函数参数初始化父类类型的成员变量？

嘿，从Java转C++确实会在内存管理上遇到不少困惑，我来帮你一步步梳理这个问题～

首先直接给你答案：完全可以避免动态内存分配，而且你的顾虑是对的——如果在构造函数里创建普通栈对象，构造函数结束后这个对象就会被销毁，成员指针会变成悬垂指针，调用它的方法会导致未定义行为（UB），绝对不能这么干。

接下来给你两种现代C++的解决方案，按需选择：

方案1：用std::variant彻底避免动态分配（C++17及以上） #

如果你的派生类数量固定，且不需要通过基类指针进行更复杂的多态操作，std::variant是最佳选择。它可以在栈上存储不同类型的对象，不需要手动管理内存，自动处理析构：

#include <variant>
#include <string>
#include <cstdio>

class Base {
public:
    virtual ~Base() = default; // 基类必须有虚析构，否则派生类析构会出问题
    virtual void doSomething() = 0;
};

class Spec1 : public Base {
public:
    Spec1() = default;
    Spec1(int i) {}
    void doSomething() override { std::printf("hello world from Spec1\n"); }
};

// 假设你还有其他派生类，比如Spec2
class Spec2 : public Base {
public:
    void doSomething() override { std::printf("hello world from Spec2\n"); }
};

// 定义一个variant类型，包含所有可能的派生类
using DerivedVariant = std::variant<Spec1, Spec2>;

class Container {
public:
    Container(const std::string& type_message) {
        if (type_message == "We need Spec1") {
            m_type = Spec1(1);
        } else if (type_message == "We need Spec2") {
            m_type = Spec2();
        }
        // 可以加默认分支，比如抛出异常或者创建默认对象
    }

    void doSomethingWithSpec() {
        // 用std::visit访问variant里的对象，调用对应的doSomething
        std::visit([](auto& obj) { obj.doSomething(); }, m_type);
    }

private:
    DerivedVariant m_type;
};

int main() {
    Container a("We need Spec1");
    a.doSomethingWithSpec();

    Container b("We need Spec2");
    b.doSomethingWithSpec();
}

这个方案里，m_type直接在栈上存储派生类对象，不需要new，也不用手动释放内存，完全符合你“避免动态分配”的需求。

方案2：用智能指针安全管理动态内存（如果必须用多态） #

如果你的场景必须用基类指针实现多态（比如派生类数量不确定，或者需要把Base*传递给其他函数），那推荐用std::unique_ptr代替裸指针——它会自动在容器销毁时释放对象，避免内存泄漏，比手动new/delete安全100倍：

#include <memory>
#include <string>
#include <cstdio>

class Base {
public:
    virtual ~Base() = default;
    virtual void doSomething() = 0;
};

class Spec1 : public Base {
public:
    Spec1() = default;
    Spec1(int i) {}
    void doSomething() override { std::printf("hello world from Spec1\n"); }
};

class Spec2 : public Base {
public:
    void doSomething() override { std::printf("hello world from Spec2\n"); }
};

class Container {
public:
    Container(const std::string& type_message) {
        if (type_message == "We need Spec1") {
            m_type = std::make_unique<Spec1>(1); // 用make_unique代替直接new
        } else if (type_message == "We need Spec2") {
            m_type = std::make_unique<Spec2>();
        }
    }

    void doSomethingWithSpec() {
        if (m_type) { // 先检查指针是否有效，避免空指针调用
            m_type->doSomething();
        }
    }

private:
    std::unique_ptr<Base> m_type; // 智能指针代替裸指针
};

int main() {
    Container a("We need Spec1");
    a.doSomethingWithSpec();
}

这里虽然还是动态分配，但std::unique_ptr会自动处理内存释放，你不用再担心忘记delete导致的内存泄漏，也不用手动管理生命周期。

几个关键注意点 #

• 基类必须有虚析构函数：你原来的代码里写了virtual ~Base(){}，这是对的！如果基类没有虚析构，当你用Base*指向派生类对象并delete时，只会调用基类的析构函数，派生类的资源不会被释放，导致未定义行为。推荐写成virtual ~Base() = default;，更符合现代C++风格。
• 绝对不能存储栈对象的地址：比如在构造函数里写Spec1 s(1); m_type = &s;，构造函数结束后s就被销毁了，m_type变成悬垂指针，调用doSomething会崩溃或者出现奇怪的行为。
• 尽量避免裸指针：现代C++里，除非你非常清楚自己在做什么，否则不要用裸指针管理动态内存，智能指针是更好的选择。

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