Question

假设我有两个课程：FirstContainer和SecondContainer
它们将相同的引用（传递给它们的构造函数）保存到类ThirdContainer。
FirstContainer和SecondContainer具有以下方法：
- addMemberToThirdContainer
- delMemberOfThirdContainer
- getThirdContainerMembers

修改ThirdContainer后，我希望其他两个人使用getThirdContainerMembers()进行更新。为此，我使用 observer / listener模式。

ThirdContainer有一个监听器列表和一个方法：addNewListener。 FirstContainer和SecondContainer注册：mThirdContainer.addNewListener(this);

我不确定这是做这个的好方法，我是面向对象的新手。
我有什么其他的可能性来实现这样的目标？我没有依附于我所陈述的任何内容，它只是在这里，因为我很难解释我想做什么。我希望它清楚。谢谢你的帮助，
最好，

编辑：什么回合使用前瞻性声明？我可以这样做：

 class ParentContainer {
 public:
     ParentContainer(ThirdContainer&)
     : mFirstContainer(*this), mSecondContainer(*this) { };

     ~ParentContainer(); 

     void addMemberToThirdContainer() {
        mThirdContainer.addMember();
        notify();
     }; 

     void delMemberOfThirdContainer() {
        mThirdContainer.delMember();
        notify();
     };

 private:
     std::vec<int>& getMemberOfThirdContainer() {
        return mThirdContainer.getMember();
     };

     void notify() {
        auto vec = getMemberOfThirdContainer();
        mFirstContainer.update(vec);
        mSecondContainer.update(vec);
     };

     ThirdContainer& mThirdContainer;
     FirstContainer  mFirstContainer;
     SecondContainer mSecondContainer; 
 };

然后在FirstContainer和SecondContainer中：

 class ParentContainer;

 class FirstContainer {
 public:
      FirstContainer(ParentContainer&);
      ~FirstContainer(); 

      void update(std::vector<int>& vec);

 private:
      ParentContainer& mParentContainer;
 };

在FirstContainer和SecondContainer中，我可以通过以下方式访问ThirdContainer：
mParentContainer.addMemberToThirdContainer和mParentContainer.DelMemberOfThirdContainer。
我会得到通知。我的意思是我猜....

Answer 1

如果您喜欢使用库，可以使用任何提供Signal / Slot系统的库，如Boost或Qt。

如果你不喜欢图书馆，你应该尝试

创建一个接口（在C ++中，只是一个带有纯虚方法的抽象类，例如onModified：

class ThirdContainerListener {
    public: virtual void onContainerModified() = 0;
    // Virtual: is to make it overridable
    //  = 0: is the C++ way to say "abstract", 
    //         which means this function MUST be overridden.
};

制作一个vector指向侦听器的指针（为了安全起见，尝试使用智能指针，如shared_ptr）{这是在ThirdContainer内部}
```
vector<shared_ptr<ThirdContainerListener>> listeners;
```

Make（也在ThirdContainer中），一个添加侦听器的函数，就像那样

void addNewListener(shared_ptr<ThirdContainerListener> container) {
    listeners.push_back(container); // Adds the pointer to the listeners
}

隐藏真正的容器，就像那样
```
private: vector<int> list;
```

创建一个调用所有侦听器的私有函数，使用LOCALLY

private: void callAllListeners() {
    // Traverse through all the listeners
    for(shared_ptr<ThirdContainerListener> listener: listeners) {
        // Call each one's overridden function
        listener->onContainerModified();
    }
}

公开修改容器的函数，那些调用所有的侦听器，就像那样

public: void addData(int d) {
            list.push_back(d);
            callAllListeners();
        }

// Also you could make "removeDataByIndex", "addManyData", etc...

在First和Second容器中使用shared_ptr<ThirdContainer>，以确保您的类不会泄漏内存或指向任何内容（悬空指针）

Answer 2

修改ThirdContainer后，我希望其他两个人使用getThirdContainerMembers()进行更新。

为什么呢？这对我来说并没有多大意义。或者至少 - 我不了解你的动机。为什么两个容器只能在实际需要时获取成员，而不是每次更新时都获得一次？或者更好的是 - 为什么要获得成员的副本，何时可以将成员保留在ThirdContainer并在那里进行迭代？

现在，你可以说＆＃34;也许迭代器在这种访问过程中失效了＃34;但在调用getThirdContainerMembers()期间，这也是一个问题。

ThirdContainer有一个监听器列表和一个方法：addNewListener。

我不喜欢这种方法，并建议您考虑是否真的想要遵循它。

我认为它更适合具有动态类型对象的解释语言，您可以动态添加或删除功能，或者至少它们具有用于观察和内省的解释器/虚拟机提供的机制。使用此类语言，您的ThirdContainer不必提前设计以支持听众。

但是，使用C ++，您将不得不强加于ThirdContainer的封装设计（或至少 - 从现有设计继承），以便它支持侦听器）。但是，另一次你需要倾听其他一些事件，你又需要继承或改变ThirdContainer的界面 - 不，我不愿意。

相反，请考虑让ThirdContainer添加元素的人负责更新共享它的FirstContainer和SecondContainer个实例;或完全避免更新。

C ++在两个类

2 个答案: