C++_design_model_observer

/*
观察者模式是一种常用的设计模式，用于在对象之间建立一种一对多的依赖关系，当被观察的对象发生变化时，
所有依赖于它的对象都能够得到通知并自动更新。下面是一个使用C++实现观察者模式的例子：
*/

#include <iostream>
#include <vector>

// 定义观察者接口
class Observer {
public:
    virtual void update(int value) = 0;
};

// 定义被观察者接口
class Subject {
public:
    virtual void attach(Observer* observer) = 0;
    virtual void detach(Observer* observer) = 0;
    virtual void notify() = 0;
};

// 具体的被观察者实现
class ConcreteSubject : public Subject {
private:
    int m_value;
    std::vector<Observer*> m_observers;

public:
    void attach(Observer* observer) override {
        m_observers.push_back(observer);
    }

    void detach(Observer* observer) override {
        for (auto it = m_observers.begin(); it != m_observers.end(); ++it) {
            if (*it == observer) {
                m_observers.erase(it);
                break;
            }
        }
    }

    void notify() override {
        for (auto observer : m_observers) {
            observer->update(m_value);
        }
    }

    void setValue(int value) {
        m_value = value;
        notify();
    }
};

// 具体的观察者实现
class ConcreteObserver : public Observer {
public:
    void update(int value) override {
        std::cout << "Value changed to " << value << std::endl;
    }
};

int main() {
    ConcreteSubject subject;
    ConcreteObserver observer1;
    ConcreteObserver observer2;

    // 将观察者添加到被观察者的观察列表中
    subject.attach(&observer1);
    subject.attach(&observer2);

    // 修改被观察者的值，观察者将会收到通知
    subject.setValue(3);

    // 将观察者从被观察者的观察列表中移除
    subject.detach(&observer2);

    // 再次修改被观察者的值，只有observer1会收到通知
    subject.setValue(5);

    return 0;
}

/*
在这个例子中，Subject是被观察者的接口，ConcreteSubject是具体的被观察者实现，Observer是观察者的接口，ConcreteObserver是具体的观察者实现。
ConcreteSubject中维护了一个观察列表，可以动态地添加和移除观察者。当被观察者的值发生改变时，它会调用notify方法来通知所有的观察者。
在main函数中，我们创建了一个ConcreteSubject对象和两个ConcreteObserver对象，将它们添加到观察列表中，并修改被观察者的值来测试观察者模式的实现。
*/

1. 运行结果