<aside> 💡

观察者模式（Observer）：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，是它们能够自动更新自己

</aside>

结构图

• 主题 / 抽象通知者（Subject）
  • 一般会定义成一个接口
  • 把所有对观察者对象的引用保存在一个聚集里，提供方法用于注册、删除和通知观察者
  • 通常也包含一个状态，当状态发生改变时，通知所有的观察者。
• 观察者（Observer）
  • 观察者也需要实现一个接口，包含一个更新方法（更新接口），在接收主题通知时执行对应的操作。
• 具体主题 / 具体通知者（ConcreteSubject）
  • 主题的具体实现，维护一个观察者列表，包含了观察者的注册、删除和通知方法。
• 具体观察者（ConcreteObserver）
  • 观察者接口的具体实现，每个具体观察者都注册到具体主题中，当主题状态变化并通知到具体观察者，具体观察者进行处理
  • 可以保存一个指向具体主题对象的引用

观察者模式的特点

• 当一个对象的改变需要同时改变其他对象，且它不知道具体有多少对象有待改变时，应该考虑适用观察者模式
• 观察者模式所做的工作其实就是在解除耦合，让耦合的双方都依赖于抽象，而不是依赖于具体，从而使得各自的变化都不会影响另一边的变化

观察者模式的不足

• 现实编程中，具体的观察者可能是完全不同的对象，但他们都需要根据通知者的通知来做出Update()操作，即都需要实现该接口
  • 但具体的更新方法名字很可能不同
• 改进方法：使用事件委托
  • 一个委托可以搭载多个方法，所有方法会被依次唤起
  • 委托对象所搭载的方法并不需要属于同一个类，但必须具有相同的原形和形式（参数列表和返回值相同）

题目

https://kamacoder.com/problempage.php?pid=1075

#include <iostream>
#include <vector>
#include <string>
using namespace std;

// 抽象的观察者类
class Observer{
public:
    // 收到通知者的通知后进行更新的方法
    virtual void update(int curTime) = 0;
};

// 抽象主题类，一个接口
class Subject{
public:
    // 添加、删除观察者
    virtual void addObserver(Observer* observer) = 0;
    virtual void removeObserver(Observer* observer) = 0;
    // 通知所有观察者
    virtual void notify() = 0;

    virtual ~Subject() = default;
};

// 具体的主题类
class ConcreteSubject: public Subject{
private:
    int curTime = 0;
    vector<Observer*> observers;
public:
    void addObserver(Observer* observer) override {
        observers.push_back(observer);
    }

    void removeObserver(Observer* observer) override {
        auto it = find(observers.begin(), observers.end(), observer);
        if(it != observers.end()){
            observers.erase(it);
        }
    }

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

    // tick()实现了时间的自增，并调用notify()通知所有观察者
    void tick(){
        curTime = (curTime + 1) % 24;
        notify();
    }
};

// 具体的观察者类
class ConcreteObserver: public Observer{
private:
    string name;
    ConcreteSubject* subject;
public:
    ConcreteObserver(string name, ConcreteSubject* subject): name(name), subject(subject){}

    void update(int curTime) override {
        cout << name << ' ' << curTime << endl;
    }
};

int main(){
    ConcreteSubject xiaominSubject;

    int n;
    cin >> n;
    for(int i = 0; i < n; ++i){
        string name;
        cin >> name;
        xiaominSubject.addObserver(new ConcreteObserver(name, &xiaominSubject));
    }

    int updateTimes;
    cin >> updateTimes;
    for(int i = 0; i < updateTimes; ++i){
        xiaominSubject.tick();
    }

    return 0;
}