编辑：

Question

现在，我需要一个类中的歧义成员。在这里，我说 ambiguous ，这意味着该成员可以属于同一基本类的两种或多种类型。请参见下面的代码。

class Base {
protected:
    int m_int;
    Base(int i) : m_int(i) {}
};

class Derived1 : Base {...};
class Derived2 : Base {...};

class AnotherClass {
private:
    Base m_member;  // <- this member
public:
    AnotherClass(int selection) {
        // if (selection)
        //     m_member = Derived1(...);
        // else
        //     m_member = Derived2(...);
    }
};

我不知道该如何初始化该成员。有什么建议吗？也许是指针/引用？

Answer 1

您应该使用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();
    }
};

Answer 2

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

Answer 3

最懒的初始化方法是在构造函数中添加一个参数。

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

请注意，但这不是添加成员的非所有权方式。

Answer 4

如评论中所建议，实现目标的正确方法是使用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做出的选择，否则复制构造函数要正确实现将特别棘手。

所以这种方法充满陷阱。

C ++多态性：是否允许模棱两可的成员类型？

4 个答案:

编辑：