State coherency across dependent classes - c++

Question

Suppose there are two classes Foo and Bar, with Bar depending on some state provided by Foo. These classes may have a structure as follows:
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()
};
Assuming that besides combining both Foo and Bar into a single class, this the way the State must be passed. Furthermore assume that there can be multiple Bar classes using the State from Foo.
When the handle_event member function is called what is the pattern or "standard" way of handling the situation such that Bar is always in a valid state?
I can imagine that something like Bar registering itself with Foo during its construction can provide such a mechanism. An example of this is below. The issue with this is I feel it may be too tightly coupled.
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

I would go with a system like the one you have proposed. It is a version of the well-established observer pattern.
If you think other types besides Bar might need state from Foo, then you could use an interface to decouple.
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;
};
A similar system could isolate Foo from Bar if necessary.