设计模式建议

发布于 2024-10-13 05:24:58 字数 400 浏览 4 评论 0原文

我想知道是否有人可以帮助我。

假设我有一些类，如下所示：

class A { ... };

class B : public A { ... }

class C : public A { ... };

class D { ... };

class E : public D { ... };

class F : public D { ... };

现在我希望类 B 有一个类型 E 的对象作为成员，类 C 有一个类型 F 的对象作为成员。

是否有一个很好的设计模式，我可以在类 A 中拥有某种指向类 D 的基指针，然后在类 B 中创建一个新的 E，在类 C 中创建一个新的 F。我想知道抽象工厂是否类似？

我希望这不会太令人困惑……没有 UML 图很难解释！。

原文

I was wondering if someone could help me.

Suppose I have some classes as follows:

class A { ... };

class B : public A { ... }

class C : public A { ... };

class D { ... };

class E : public D { ... };

class F : public D { ... };

Now I want class B to have an object of type E as a member and class C to have a object of type F as a member.

Is there a nice design pattern whereby I can have some sort of base pointer to class D in class A and then create a new E in class B and a new F in class C. I was wondering if abstract factory is similar?.

I hope this is not too confusing ... it is hard to explain without UML diagrams!.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

冷︶言冷语的世界 2024-10-20 05:24:58

完全按照你说的做有什么问题吗？

class A
{
    A(D* p) : ptr(p) {}
    D* ptr;
};

class B : public A
{
    B() : A(new E) {}
};

class C : public A
{
    C() : A(new F) {}
};

如果您想更好地自动化它，可以使用中间模板类。

class A
{
    virtual D* getD();
};

template <class T>
class AImpl : public A
{
    AImpl() : m_d(new T) {}
    T* getD() { return m_d; }
    T* m_d;
};

class B : public AImpl<E> { };

class C : public AImpl<F> { };

请注意，由于协变返回类型。

What's wrong with just doing exactly as you say?

class A
{
    A(D* p) : ptr(p) {}
    D* ptr;
};

class B : public A
{
    B() : A(new E) {}
};

class C : public A
{
    C() : A(new F) {}
};

If you want to automate it a bit better, you can use an intermediate template class.

class A
{
    virtual D* getD();
};

template <class T>
class AImpl : public A
{
    AImpl() : m_d(new T) {}
    T* getD() { return m_d; }
    T* m_d;
};

class B : public AImpl<E> { };

class C : public AImpl<F> { };

Note that AImpl::getD() can return T* due to covariant return types.

回复收藏 0 原文

陌伤ぢ 2024-10-20 05:24:58

您完全可以这样做：

class D
{
public:
    D(const A *p) : p_(p) {}
    virtual ~D() { delete p_; }
private:
    const A *p_;
};

class E : public D
{
public:
    E() : D(new B) {}
};

有很多更好的方法可以实现这一点，具体取决于您想要实现的目标。例如，为什么D需要包含指向A的指针？

也许如果您编辑问题以更好地解释您的目标，那么我们可以提供更有洞察力的答案。

You can do exactly that:

class D
{
public:
    D(const A *p) : p_(p) {}
    virtual ~D() { delete p_; }
private:
    const A *p_;
};

class E : public D
{
public:
    E() : D(new B) {}
};

There are many better approaches to this, depending on what you're trying to achieve. For instance, why does D need to contain the pointer to the A?

Perhaps if you edit your question to better explain your goal, then we can provide more insightful answers.

回复收藏 0 原文