Question

我试图确定设计问题的正确方法，但我很难找到正确的方法。

简单来说：

我有多个功能类，每个功能类都需要与多个公共类进行交互。（所有在新建的堆上创建）

例如

A class [a] object needs to be able to call methods in class [x], [y] & [z] objects
A class [b] object needs to be able to call methods in class [x], [y] & [z] objects
A class [c] object needs to be able to call methods in class [x], [y] & [z] objects

到目前为止我有3个解决方案：

创建公共类（x，y，z）全局对象（或单例），因此函数类（a，b，c）可以直接调用对象。但是，我不喜欢把事情做成全球化的想法。
在初始化期间将指针传递给公共类（x，y，z）到每个功能类（a，b，c）以供以后使用。但是，如果删除了公共类，则函数类具有过时的指针。
拥有一个管理＆＃39;的单个全局对象（可能是单个对象）。公共类（x，y，z）和函数类（a，b，c）在需要时从此全局对象请求公共类指针。这允许他们立即知道指针是否为NULL。

以前，我已经使用了（2），但随着时间的推移，我对这种方法感到不满。

我认为我目前偏爱（3），但仍然对拥有全局对象/单身人士感到不舒服。

我一直在寻找适合这种情况的设计模式，但找不到合适的东西，可能是由于不知道正确的关键字。

这个问题有共同的设计方法/模式吗？

Answer 1

如果没有看到问题的更多细节，很难提供建议，但根据你的说法，我会选择2。

如果正确管理生命周期，最好使用RAII和资源管理对象，则在删除功能类之前没有理由删除公共类。

您说所有类都是使用new在堆上创建的，但您可以使用类似std::unique_ptr的内容来管理生命周期：

#include <memory>

struct X { };
struct Y { };
struct Z { };

class A {
    X* x_;
    Y* y_;
    Z* z_;
  public:
    A(X* x, Y* y, Z* z) : x_(x), y_(y), z_(z) { } 
    void doSomething() { /* use x_, y_ and z_ ... */ }
};

// Similarly for B and C ...

int main() {
    auto x = std::make_unique<X>();
    auto y = std::make_unique<Y>();
    auto z = std::make_unique<Z>();

    auto a = std::make_unique<A>(x.get(), y.get(), z.get());
    a->doSomething();
}

如果x，y和z总是一起使用，或者应该懒得创建，你可以选择类似选项3并将它们组合成一个“管理”对象，但我会如果可以的话，避免使管理对象成为全局/单例，只需通过引用或指针将其传递给函数类的初始化，如选项2所示：

struct XYZ {
  std::unique_ptr<X> x;
  std::unique_ptr<Y> y;
  std::unique_ptr<Z> z;
  XYZ():x(std::make_unique<X>()), y(std::make_unique<Y>()), z(std::make_unique<Z>()){}
};

class A {
    XYZ* xyz_;
  public:
    A(XYZ* xyz) : xyz_(xyz) { } 
    void doSomething() { /* use xyz_ ... */ }
};

// Similarly for B and C ...

int main() {
    XYZ xyz;
    auto a = std::make_unique<A>(&xyz);
    a->doSomething();
}

如何让多个类共享指向公共类的指针

1 个答案: