C++在另一个类中使用抽象类对象的设计模式

Question

我有一个带有 2 个纯虚方法的类和另一个需要使用此类对象的类。我想允许此类的用户指定应在其中使用抽象类的哪个派生。 我正在努力找出正确的方法是什么。

struct abstract {
    virtual int fst_func() = 0;
    virtual void sec_func(int) = 0;
};

// store an instance of "abstract".
class user_of_abstract
{
private:
    abstract* m_abstract;

public:
    // Pass a pointer to an "abstract" object. The caller takes care of the memory resource.
    user_of_abstract_base(abstract* a) : m_abstract(a) { }

    // Pase any type, which needs to be derived from "abstract" and create a copy. Free memory in destructor.
    template<class abstract_type>
    user_of_abstract_base(abstract_type const& a) : m_abstract(new abstract_type(a)) { }

    // use the stored member to call fst_func.
    int use_fst_func() {
        return this->m_abstract->fst_func();
    }

    // use the stored member to call sec_func.
    void use_sec_func(int x) {
        this->m_abstract->sec_func(x);
    }
};

// use boost::shared_ptr
class user_of_abstract
{
private:
    boost::shared_ptr<abstract> m_abstract;

public:
    // Pass a pointer to an "abstract" object. The caller takes care of the memory resource.
    user_of_abstract_base(boost::shared_ptr<abstract> a) : m_abstract(a) { }

    // use the stored member to call fst_func.
    int use_fst_func() {
        return this->m_abstract->fst_func();
    }

    // use the stored member to call sec_func.
    void use_sec_func(int x) {
        this->m_abstract->sec_func(x);
    }
};

// pass a pointer of an "abstract" object wherever needed.
struct user_of_abstract
{
    // use the passed pointer to an "abstract" object to call fst_func.
    int use_fst_func(abstract* a) {
        return a->fst_func();
    }

    // use the passed pointer to an "abstract" object to call sec_func.
    void use_sec_func(abstract* a, int x) {
        a->sec_func(x);
    }
};

值得注意的是，sec_func() 中的参数“x”需要是 fst_func() 在同一“抽象”实例上返回的值。

编辑： 添加了另一种使用 boost::shared_ptr 的方法，该方法应该发挥最大的优势。

Answer 1

我想说，将 abstract 对象传递到用户的构造函数中是正确的方法，因为用户的方法依赖于在同一个 abstract 对象上调用。我什至会更进一步，将 x 参数设置为用户的内部状态，正如您所说，该值是从第一个函数调用返回的值，这一点很重要。

更新：如果您担心生命周期，那么您可以使用 boost 等中提供的各种智能指针选项。这些应该涵盖大多数使用场景。

Answer 2

既然你说第二个函数应该使用第一个函数的输出。我想第一种方法会减少出错的机会。您甚至可以将其修改为以下内容：

int use_fst_func() {
    return x=this->m_abstract->fst_func();
}

void use_sec_func() {
    this->m_abstract->sec_func(x);
}

protected:
   int x;

Answer 3

您正让自己陷入维护麻烦的海洋之中。

在您的第一个示例中...

确实不需要模板构造函数。它被指定为

// Parse any type, which needs to be derived from "abstract" and create a copy.

用户已经可以通过自己创建实例并将其传递给第一个构造函数来做到这一点。

另外，这样：

// Free memory in destructor.

您明确表示您不知道应该如何使用这个类。在编写第一个示例时，您需要决定：使用从外部创建的实例还是使用在内部创建的实例。看到一个接口，一个 ctor 接受一个指针，另一个 ctor 接受一个引用，这两者本质上都是相同的类型，这是令人困惑的。

在我看来，使用从外部创建的不受内存管理的实例或从内部创建的受内存管理的实例的唯一可接受的方法是存在默认构造函数可以将内部指针初始化为一个合理的值（但这里似乎不是这种情况，因为您想复制另一个实例）：

template <typename T>
class user_of_abstract
{
    bool m_owner_;
    abstract* m_abstract;

public:

    user_of_abstract_base(abstract* a = NULL)
    : m_owner(a == NULL)
    , m_abstract(m_owner ? new T(): a)
    {
    }

    ~user_of_abstract_base()
    {
        if (m_owner)
        {
            delete m_abstract;
        }
    }
}

您的第二个示例...

优于第一个，因为您没有明确地将内存管理与内存引用混合在一起。您让 shared_ptr 隐式地执行此操作。非常好，就是为了这个。

但是，由于您要求 use_sec_func 必须将 use_fst_func 的输出作为输入，因此您距离维护问题的安全海岸还很远。

例如，如果实例上的 use_fst_func 引发异常并且稍后在同一实例上调用 use_sec_func ，会发生什么情况？

您如何期望重要信息“始终在 B 之前调用 A。并且仅一次。并将 A 结果传递给 B。”应该在 2 年后传播给该类的用户吗？

为什么 use_sec_func 不能直接调用 use_fst_func？

至于你的第三个例子...

当你想使用它而不是直接调用实例函数时，你能给出1个场景吗？