C ++类/层次结构设计

Question

我粗略地讲了以下层次结构

class Base {
public:
    virtual int value() const = 0;
};

class Derived1 : public Base {
public:
    int value() const {
        return 1;
    }
};

class Derived2 : public Base {
public:
    int value() const {
        return -1;
    }
};

class Derived3 : public Base {
public:
    Derived3(const Base & underlying);
    int value() const {
        return underlying_.value() + 10;
    }
private:
    const Base & underlying_;
};

Derived3::Derived3(const Base & underlying)
:underlying_(underlying) {}

还有一个用于基础对象的单例持有者。工作流程的一个分支是这样的：
1) 从holder中获取一个Derived1对象
2）使用Derived1对象实例化Derived3对象并使用它。

我处于多线程环境中，担心底层_引用_在第二个对象的生命周期内变得无效的问题。我不是多线程专家，但我相信这可能会发生。

我希望 Derived2 对象拥有底层对象的副本，但因为 Base 是抽象的，所以我不能这样做。有人可以评论这个设计并提出不同的方法吗？

补充一下，上述设计背后有两个驱动思想。 Derived3 应该被视为 Base 类型对象的转变。一种愿望是轮班轮班。另一个愿望是能够将 Derived3 对象存储在单例中以供以后使用。

Answer 1

您可以尝试“克隆”您的课程。我的意思是，每个派生类都可以克隆自身并在其他派生类中使用此克隆。

class Base {
    public:
        virtual Base *clone() const = 0;
};

class Derived2 : public Base {
    public:
        int value() const {
           return -1;
        }
        Derived2(const Derived2 &)
        {
            ....
        }
        Base *clone() const
        {
            return new Derived2(*this);
        }
};

通过此解决方案，您可以随时保留新的 Derived。不要忘记删除它。您的工厂返回一个 Base 对象，可以克隆该对象以获得新对象。

Answer 2

当您只有抽象类的指针或引用时，克隆是制作副本的常用方法。

struct A {
  virtual A* clone() const = 0;
  virtual ~A() { }
};

struct B : A {
  virtual A* clone() const { return new B(*this); }
};

struct C {
  A* ap;

  C(A* ap_arg) : ap(ap_arg->clone()) { }
  ~C() { delete ap; }
};