Question

假设有两个类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的方式。此外，假设使用State中的Foo可以有多个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); };之类的东西可以提供这样的机制。下面是一个例子。这个问题是我觉得它可能太紧密了。

/usr/include

Answer 1

我会使用你提出的系统。它是完善的observer模式的一个版本。

如果您认为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隔离开来。

国家对依赖班级的一致性

1 个答案: