设计模式-观察者模式

在C++中，观察者模式（Observer Pattern）是一种行为设计模式，用于定义对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都将得到通知并自动更新。以下是一个简单的C++观察者模式的示例：

示例一：

cpp 复制代码

#include <iostream>
#include <vector>

// 前向声明
class Observer;

// 主题类
class Subject {
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    void notify() {
        for (Observer* observer : observers) {
            observer->update();
        }
    }

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

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

// 具体观察者类
class ConcreteObserver : public Observer {
public:
    ConcreteObserver(const std::string& name) : name(name) {}

    void update() override {
        std::cout << name << " has been notified." << std::endl;
    }

private:
    std::string name;
};

int main() {
    Subject subject;
    ConcreteObserver observer1("Observer 1");
    ConcreteObserver observer2("Observer 2");

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

    // 主题状态发生变化，通知观察者
    subject.notify();

    return 0;
}

在这个示例中，Subject（主题）维护了一个Observer（观察者）的列表，可以动态添加和删除观察者。当Subject的状态发生变化时，调用notify方法通知所有观察者更新。Observer定义了一个纯虚函数update，具体的观察者类ConcreteObserver实现了update方法，在update方法中定义了具体的更新逻辑。

这个示例展示了一个简单的观察者模式实现，你可以根据实际需求扩展和修改代码来满足具体的场景。观察者模式在C++中常用于实现异步消息通知、事件处理等场景。

示例二：

cpp 复制代码

#include <iostream>
#include <vector>

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

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

// 主题类
class Subject {
private:
    std::vector<Observer*> observers;  // 存储观察者对象的向量

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

    // 移除观察者
    void detach(Observer* observer) {
        auto it = std::find(observers.begin(), observers.end(), observer);
        if (it!= observers.end()) {
            observers.erase(it);
        }
    }

    // 通知所有观察者
    void notifyObservers() {
        for (Observer* observer : observers) {
            observer->update();
        }
    }
};

int main() {
    // 创建主题对象
    Subject subject;

    // 创建具体观察者对象
    ConcreteObserver observer1;
    ConcreteObserver observer2;

    // 注册观察者
    subject.attach(&observer1);
    subject.attach(&observer2);

    // 模拟主题状态改变
    subject.notifyObservers();

    // 移除观察者
    subject.detach(&observer1);

    // 再次模拟主题状态改变
    subject.notifyObservers();

    return 0;
}

在上述示例中，我们定义了一个抽象的Observer类，以及一个具体的ConcreteObserver类来实现具体的更新逻辑。Subject类作为主题，维护了一个观察者列表，并提供了添加、移除和通知观察者的方法。

在main函数中，我们创建了主题对象和两个具体的观察者对象，并将它们注册到主题上。然后，通过模拟主题状态的改变，触发通知观察者的操作，使得观察者能够得到更新。

这只是一个简单的观察者模式实现示例，实际应用中可能需要根据具体需求进行更复杂的设计和实现。例如，可能需要支持动态添加和移除观察者、处理观察者的优先级等。根据实际情况，可以对这个示例进行扩展和改进