观察者模式

#include <iostream>
#include <vector>

// 抽象观察者类
class Observer {
public:
    virtual void update() = 0;
};

// 具体观察者类A
class ConcreteObserverA : public Observer {
public:
    void update() override {
        std::cout << "ConcreteObserverA::update()" << std::endl;
    }
};

// 具体观察者类B
class ConcreteObserverB : public Observer {
public:
    void update() override {
        std::cout << "ConcreteObserverB::update()" << std::endl;
    }
};

// 抽象主题类
class Subject {
protected:
    std::vector<Observer*> observers; // 观察者列表

public:
    virtual void attach(Observer* observer) { // 添加观察者
        observers.push_back(observer);
    }

    virtual void detach(Observer* observer) { // 移除观察者
        for (auto it = observers.begin(); it != observers.end(); ++it) {
            if (*it == observer) {
                observers.erase(it);
                return;
            }
        }
    }

    virtual void notify() { // 通知所有观察者
        for (auto observer : observers) {
            observer->update();
        }
    }
};

// 具体主题类
class ConcreteSubject : public Subject {
public:
    void operation() { // 主题对象的操作
        std::cout << "ConcreteSubject::operation()" << std::endl;
        notify(); // 通知所有观察者
    }
};

int main() {
    // 创建具体主题对象和观察者对象
    ConcreteSubject* subject = new ConcreteSubject();
    Observer* observerA = new ConcreteObserverA();
    Observer* observerB = new ConcreteObserverB();

    // 将观察者对象添加到主题对象的观察者列表中
    subject->attach(observerA);
    subject->attach(observerB);

    // 主题对象执行操作，通知所有观察者
    subject->operation();

    // 将观察者对象从主题对象的观察者列表中移除
    subject->detach(observerA);

    // 主题对象执行操作，通知剩余观察者
    subject->operation();

    // 释放资源
    delete observerA;
    delete observerB;
    delete subject;

    return 0;
}