假设有两个类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
隔离开来。