c++ - 跨依赖类的状态一致性

Question

假设有两个类 Foo 和 Bar，Bar 取决于 Foo 提供的一些状态。这些类可能具有如下结构:

class Foo
{
public:
  // Constructors and destructors

  const State& get_state() const;

  /* Invalidates and recreates the 'State' object passed by 'get_state' */
  void handle_event();

private:
  // private member variables
};

class Bar
{
public:
  Bar(const Foo& foo);

private:
  const State& m_state; //Assigned via foo.get_state()
};

假设除了将 Foo 和 Bar 组合成一个类之外，还必须以这种方式传递 State。此外假设可以有多个使用 Foo 中的 State 的 Bar 类。

当 handle_event 成员函数被调用时，处理这种情况的模式或“标准”方式是什么，使得 Bar 始终处于有效状态？

我可以想象像 Bar 这样的东西在构造过程中将自己注册到 Foo 可以提供这样的机制。下面是一个例子。这个问题是我觉得它可能耦合得太紧了。

class Foo
{
public:
  void register_dependency(Bar* bar);
  void deregister_dependency(Bar* bar);

private:
  std::set<Bar *> m_dependencies;
};

class Bar
{
public:
  void invalidate_state(const Foo& foo);
};

Answer 1

我会选择像您提议的那样的系统。它是行之有效的版本observer图案。

如果您认为 Bar 之外的其他类型可能需要来自 Foo 的状态，那么您可以使用接口(interface)来解耦。

class Foo;
class IFooStateObserver {
public:
    virtual ~IFooStateObserver() {}
    virtual void invalidate_state(const Foo& foo) = 0;
};

class Foo {
public:
    void register_dependency(IFooStateObserver* observer);
    void deregister_dependency(IFooStateObserver* observer);

private:
    std::set<IFooStateObserver*> m_dependencies;
};

class Bar : public IFooStateObserver {
public:
    void invalidate_state(const Foo& foo) override;
};

如有必要，类似的系统可以将 Foo 与 Bar 隔离。