跨依赖类的状态一致性

State coherency across dependent classes

本文关键字：状态 一致性 依赖      更新时间：2023-10-16

假设有两个类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。此外，假设可以有多个Bar类使用 Foo 中的State。

当调用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);
};

我会选择像你提出的系统。 它是既定观察者模式的一个版本。

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

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隔离开来。

相关文章：