Observer Pattern

#include <iostream>
#include <vector>
#include <algorithm>

// Observer interface
class Observer {
public:
    virtual void update(const std::string& message) = 0;
};

// Concrete Observer
class ConcreteObserver : public Observer {
public:
    ConcreteObserver(const std::string& name) : name(name) {}

    void update(const std::string& message) override {
        std::cout << name << " received a notification: " << message << std::endl;
    }

private:
    std::string name;
};

// Subject
class Subject {
public:
    void addObserver(Observer* observer) {
        observers.push_back(observer);
    }

    void removeObserver(Observer* observer) {
        // Remove the observer from the list
        auto it = std::remove(observers.begin(), observers.end(), observer);
        observers.erase(it, observers.end());
    }

    void notify(const std::string& message) {
        for (auto observer : observers) {
            observer->update(message);
        }
    }

private:
    std::vector<Observer*> observers;
};

int main() {
    ConcreteObserver observer1("Observer 1");
    ConcreteObserver observer2("Observer 2");
    ConcreteObserver observer3("Observer 3");

    Subject subject;

    subject.addObserver(&observer1);
    subject.addObserver(&observer2);

    subject.notify("Notification 1");
    /*
      Observer 1 received a notification: Notification 1
      Observer 2 received a notification: Notification 1
     */

    subject.addObserver(&observer3);
    subject.notify("Notification 2");
    /*
        Observer 1 received a notification: Notification 2
        Observer 2 received a notification: Notification 2
        Observer 3 received a notification: Notification 2
     */

    subject.removeObserver(&observer1);
    subject.notify("Notification 3");
    /*
        Observer 2 received a notification: Notification 3
        Observer 3 received a notification: Notification 3
     */
    return 0;
}