Implementing Observer Pattern with References

The Observer pattern is a software design pattern where an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes. We can implement this pattern in C++ using references for a clean and efficient design.

Here's a simple implementation:

1#include <iostream>
2#include <string>
3#include <vector>
4
5class Observer {
6 public:
7  virtual void Update(
8    const std::string& message) = 0;
9  virtual ~Observer() = default;
10};
11
12class Subject {
13 private:
14  std::vector<Observer*> observers;
15  std::string state;
16
17 public:
18  void Attach(Observer& observer) {
19    observers.push_back(&observer);
20  }
21
22  void Detach(Observer& observer) {
23    observers.erase(std::remove(
24      observers.begin(),
25      observers.end(),
26      &observer
27    ), observers.end());
28  }
29
30  void SetState(const std::string& newState) {
31    state = newState;
32    Notify();
33  }
34
35  void Notify() {
36    for (auto observer : observers) {
37      observer->Update(state);
38    }
39  }
40};
41
42class ConcreteObserver : public Observer {
43 private:
44  std::string name;
45
46 public:
47  ConcreteObserver(const std::string& observerName)
48  : name{observerName} {}
49
50  void Update(const std::string& message) override {
51    std::cout << name << " received message: "
52      << message << '\n';
53  }
54};
55
56int main() {
57  Subject subject;
58
59  ConcreteObserver observer1{"Observer 1"};
60  ConcreteObserver observer2{"Observer 2"};
61
62  subject.Attach(observer1);
63  subject.Attach(observer2);
64
65  subject.SetState("Hello, observers!");
66
67  subject.Detach(observer2);
68
69  subject.SetState("Observer 2 won't see this.");
70}

1Observer 1 received message: Hello, observers!
2Observer 2 received message: Hello, observers!
3Observer 1 received message: Observer 2 won't see this.

Let's break this down:

1. We define an Observer interface with a pure virtual Update() method.
2. The Subject class maintains a list of observer pointers. We use pointers here because std::vector can't store references directly.
3. The Attach() and Detach() methods in Subject take references to Observer objects. This provides a clean syntax for the user of the class and ensures that null observers can't be attached.
4. When SetState() is called, it updates the state and calls Notify(), which updates all observers.
5. ConcreteObserver is an implementation of the Observer interface.
6. In main(), we create a subject and two observers, attach the observers, set the subject's state (which notifies the observers), detach an observer, and set the state again.

Using references in the Attach() and Detach() methods provides several benefits:

• It's more intuitive: passing by reference clearly communicates that we're working with an existing object.
• It's safer: you can't pass a null reference, unlike with pointers.
• It's efficient: no need to check for null before dereferencing.

Remember, while we're using references in the interface, we're storing pointers internally. This is a common pattern when you need a mutable collection of references.