观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生改变时，它的所有观察者都会收到通知并更新自己的状态。

观察者模式的主要角色有：

• Subject（主题）：它是被观察的对象，当它的状态发生改变时，会通知所有观察者。
• Observer（观察者）：它定义了一个更新接口，当主题对象的状态发生改变时，它会得到通知并进行相应的处理。
• ConcreteSubject（具体主题）：它是具体的被观察对象，它包含了需要监视的状态。
• ConcreteObserver（具体观察者）：它是具体的观察者对象，它实现了 Observer 接口，并根据具体业务进行相应的处理。

下面是一个使用观察者模式实现的简单例子，我们将实现一个气象站的功能，主题对象是气象数据，观察者对象是显示器，当气象数据发生改变时，所有的显示器都会更新显示。

复制#include <iostream>
#include <vector>

using namespace std;

// 抽象主题
class Subject {
public:
    virtual ~Subject() {}
    virtual void RegisterObserver(class Observer* observer) = 0;
    virtual void RemoveObserver(class Observer* observer) = 0;
    virtual void NotifyObservers() = 0;
};

// 抽象观察者
class Observer {
public:
    virtual ~Observer() {}
    virtual void Update(float temperature, float humidity, float pressure) = 0;
};

// 具体主题
class WeatherData : public Subject {
public:
    WeatherData() : temperature_(0), humidity_(0), pressure_(0) {}
    virtual void RegisterObserver(Observer* observer) override {
        observers_.push_back(observer);
    }
    virtual void RemoveObserver(Observer* observer) override {
        for (auto it = observers_.begin(); it != observers_.end(); ++it) {
            if (*it == observer) {
                observers_.erase(it);
                break;
            }
        }
    }
    virtual void NotifyObservers() override {
        for (auto observer : observers_) {
            observer->Update(temperature_, humidity_, pressure_);
        }
    }
    void MeasurementsChanged() {
        NotifyObservers();
    }
    void SetMeasurements(float temperature, float humidity, float pressure) {
        temperature_ = temperature;
        humidity_ = humidity;
        pressure_ = pressure;
        MeasurementsChanged();
    }
private:
    vector<Observer*> observers_;
    float temperature_;
    float humidity_;
    float pressure_;
};

// 具体观察者
class CurrentConditionsDisplay : public Observer {
public:
    CurrentConditionsDisplay(Subject* subject) : subject_(subject) {
        subject->RegisterObserver(this);
    }
    virtual ~CurrentConditionsDisplay() {
        subject_->RemoveObserver(this);
    }
    virtual void Update(float temperature, float humidity, float pressure) override {
        temperature_ = temperature;
        humidity_ = humidity;
        Display();
    }
    void Display() {
        cout << "Current conditions: " << temperature_ 
            << "F degrees and " << humidity_ << "% humidity" << endl;
    }
private:
    Subject* subject_;
    float temperature_;
    float humidity_;
};

int main() {
    WeatherData weather_data;
    CurrentConditionsDisplay current_display(&weather_data);
    weather_data.SetMeasurements(80, 65, 30.4);
    weather_data.SetMeasurements(82, 70, 29.2);
    weather_data.SetMeasurements(78, 90, 29.2);
    return 0;
}

在上面的代码中，WeatherData 是主题，Observer 是观察者，CurrentConditionsDisplay 是具体观察者。当 WeatherData 的气象数据发生改变时，会调用 NotifyObservers() 方法，通知所有的观察者，包括 CurrentConditionsDisplay，它会更新自己的状态并调用 Display() 方法显示更新后的信息。

这就是一个简单的 C++ 观察者模式的实现例子。