Observer

Intent

Defines a subscription mechanism that notifies multiple objects about events in the object they observe.

Problem

Customers keep polling the store for a new product, or the store spams everyone.

Solution

The publisher keeps a list of subscribers and notifies them when something happens. Events, signals and pub/sub are all Observer.

Real-world analogy

Structure

Hover or tap a numbered role to highlight it in the diagram.

1. 1Publisher — Publisher issues events and keeps the subscription list.
2. 2Publisher — When an event happens, it loops over subscribers and calls update().
3. 3Subscriber — Subscriber declares the notification interface, usually a single update method.
4. 4ConcreteSubscribers — Concrete Subscribers react to notifications.
5. 5Client — Client creates publishers and subscribers and registers subscriptions.

Try it

Code example

template <typename Event>
class Subject {
public:
    using Handler = std::function<void(const Event&)>;
    void subscribe(Handler h) { handlers.push_back(std::move(h)); }
    void notify(const Event& e) const {
        for (const auto& h : handlers) h(e);
    }
private:
    std::vector<Handler> handlers;
};

// Subject<std::string> saved;
// saved.subscribe([](const std::string& name) { std::cout << "Saved " << name << '\n'; });
// saved.notify("report.txt");

Applicability

How to implement

1. Split business logic into a publisher and subscribers
2. Declare the subscriber interface (often a callback type)
3. Add subscribe / unsubscribe to the publisher
4. Notify subscribers when the event happens
5. Subscribers register with publishers

Pros and cons

Relations with other patterns

Check yourself