您应该使用std::variant，指针或类型删除的包装器(编辑：我在最后添加了一个通用类型删除的包装器实现(。这是指针解决方案：

class AnotherClass {
private:
    std::unique_ptr<Base> m_member;
public:
    AnotherClass(int selection) {
        if (selection)
            m_member = std::make_unique<Derived1>(...);
        else
            m_member = std::make_unique<Derived2>(...);
    }
};

不幸的是，AnotherClass只能移动，而不是共配。如果您想能够复制它，则必须提供复制构造函数。复制构造函数必须能够克隆成员：

class Base {
protected:
    int m_int;
    Base(int i) : m_int(i) {}
public:
    // For covariance, return a raw pointer instead.
    virtual std::unique_ptr<Base> clone() const = 0;
};
class Derived1 : public Base {
public:
   std::unique_ptr<Base> clone() const override { 
      return std::make_unique<Derived1>();
   }
...
};
class Derived2 : public Base { .. same ... };
class AnotherClass {
public:
   AnotherClass(const AnotherClass & other) : m_member(other.m_member->clone()) {}
   AnotherClass(AnotherClass && other) = default;
   .... same for assignment ...

编辑：

一种替代方法是使用一个基于类型的包装器，它照顾丑陋的东西：

#include <type_traits>
#include <memory>
template <class BaseType>
struct AbstractWrapper {
public:
    virtual ~AbstractWrapper() = default;
    virtual std::unique_ptr<AbstractWrapper<BaseType>> clone() = 0; 
    virtual BaseType * get() = 0;
};
template <class BaseType, class T>
struct ConcreteWrapper : public AbstractWrapper<BaseType> {
    static_assert(std::is_base_of<BaseType, T>::value);
    T data;
    template <class U, class = std::enable_if_t<(!std::is_same_v<ConcreteWrapper, std::decay_t<U>>)>>
    ConcreteWrapper(U && value) : data(std::forward<U>(value)) {}
    std::unique_ptr<AbstractWrapper<BaseType>> clone() override
    {
        return std::make_unique<ConcreteWrapper>(*this);
    }
    BaseType * get() override { return &data; } 
};
template <class BaseType>
class TypeErasedWrapper
{
public:    
    TypeErasedWrapper(const TypeErasedWrapper & other) 
        : container(other.container->clone()) 
    {}
    TypeErasedWrapper(TypeErasedWrapper && other) = default;
    TypeErasedWrapper() {}

    template <class U, class = std::enable_if_t<std::is_base_of_v<BaseType, std::decay_t<U>>>>
    TypeErasedWrapper(U && concrete) {
        container = std::make_unique<ConcreteWrapper<BaseType, std::decay_t<U>>>(std::forward<U>(concrete));
    }
    template <class U>
    TypeErasedWrapper& operator = (U && concrete) {
        *this = TypeErasedWrapper(std::forward<U>(concrete));
        return *this;
    }
    TypeErasedWrapper& operator=(const TypeErasedWrapper & other) {
        container = other.container->clone();
        return *this;
    }
    TypeErasedWrapper& operator = (TypeErasedWrapper && other) = default;
    BaseType * operator->() { return container->get();}
    const BaseType * operator->() const { return container->get();}
    BaseType * get() { return container ? container->get() : nullptr;}
    const BaseType * get() const { return container? container->get() : nullptr;}

private:
   std::unique_ptr<AbstractWrapper<BaseType>> container;
};

用法：

class AnotherClass {
private:
    TypeErasedWrapper<Base> m_member;
public:
    AnotherClass(int selection) {
        if (selection)
            m_member = Derived1(...);
        else
            m_member = Derived2(...);
    }
    int getValue() const {
       // Assuming getBaseValue() is a method of Base
       return m_member->getBaseValue();
    }
};

static const Base& Base::getDerivedClass(int derivedID) {
    if(derivedID == 1) return Derived1();
    .... 
} 
AnotherClass(int derivedID) : m_member(Base::getDerivedClass(derivedID))

初始化的最懒惰的方式是向构造函数添加一个参数。

private:
    Base& m_member;
public:
    AnotherClass(Base& ref) : m_member(ref) {}

请注意，这将是添加成员的一种非拥有方式。

如评论中所建议的，实现目标的正确方法是使用std::unique_ptr<Base>。

class AnotherClass {
private:
    std::unique_ptr<Base> m_ptr;
public:
    AnotherClass (int selection) {
        if (selection) m_ptr = std::make_unique<Derived1>();
        else m_ptr = std::make_unique<Derived2>();
    }
    //...
}

您可以使用放置新，，但这是一个坏主意。

union DerivedAny {
    char m_mem1[sizeof(Derived1)] alignas(Derived1);
    char m_mem2[sizeof(Derived2)] alignas(Derived2);
};
class AnotherClass {
private:
    char m_mem[sizeof(DerivedAny)] alignas(DerivedAny);
    Base * base () { return reinterpret_cast<Base *>(m_mem); }
public:
    AnotherClass (int selection) {
        if (selection) new (m_mem) Derived1;
        else new (m_mem) Derived2;
    }
    //...
};

由于构建了m_mem，因此AnotherClass需要一个破坏者才能正确清洁。

    ~AnotherClass () { base()->~Base(); }

然后您需要定义一个适当的复制构造函数和分配运算符。副本构造函数将特别棘手地执行，除非您可以恢复selection的选择。

因此，这种方法充满了陷阱。