设计模式之观察者模式

场景

​ 在构筑代码过程中，我们需要在某个对象发生改变时，让其他对象做出反应。如果要其他对象时刻关注这个对象的状态的话，势必会消耗部分性能，而且实现起来也十分麻烦。观察者模式为我们提供了这种一对多关系的解决方案。

定义

​ 观察者模式：定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。

结构

​ 观察者模式结构如下：

• Subject：跟踪所有观察者，并提供添加和删除观察者的接口。
• Observer：为所有的具体观察者定义一个接口，在得到主题的通知时进行更新。
• ConcreteObserver：实现Observer所要求的更新接口，以便使本身的状态与主题相协调。
• ConcreteSubject：将有关状态存入各ConcreteObserver对象，当ConcreteSubject的状态发生任何更改时，通知所有观察者。

实现

​ 假设，我们需要在某个对象的值改变之后，更新其他对象的值。

Subject：

class Subject{
  public:
    virtual void Attach(Observer*) = 0;
    virtual void Detach(Observer*) = 0;
    virtual void Notify() = 0;
};

ConcreteSubject：

class ConcreteSubject : public Subject{
  public:
    ConcreteSubject(){m_value = 0;}
    
    void SetValue(int value){m_value = value;}
    
    void Attach(Observer* observer){m_observers.push_back(observer);}
    
    void Detach(Observer* observer){m_observers.remove(observer);}
    
    void Notify(){
        for(auto it = m_observers.begin(); it != m_observer.end(); ++it){
            (*it)->Update(m_value);
        }
    }
    
  private:
    int m_value;
    std::list<Observer*> m_observers;
};

Observer：

class Observer{
  public:
    virtual void Update(int value) = 0;
};

ConcreteObserver：

class ConcreteObserver : public Observer{
  public:
    ConcreteObserver(std::string name):m_name(name){}
    
    void Update(int value){
        m_value = value;
        std::cout << m_name << ":" << m_value << std::endl;
    }
    
  private:
    std::string m_name;
    int m_value;
};

Client:

int main(){
    ConcreteSubject *pSubject = new ConcreteSubject();
    Observer* pObserverA = new ConcreteObserver("A");
    Observer* pObserverB = new ConcreteObserver("B");
    
    pSubject->Attach(pObserverA);
    pSubject->Attach(pObserverB);
    
    pSubject->SetValue(100);
    pSubject->Notify();
    
    return 0;
}