设计模式（行为型模式）之：Observer（观察者模式）

动机

在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系” - 一个对象（目标对象）的状态改变，所有的依赖对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化
使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系，从而实现软件体系结构的松耦合
定义
定义对象间的一种一对多（变化）的依赖关系，以便当一个对象（Subject）的状态发生改变时，所有依赖于它的对象都能得到通知并自动更新

使用场景

当一个类模块需要从另一个类模块获取信息，而这两者又无法用继承、组合的方式来描述时。
获取通知的的模块需要获取发送通知的模块的信息，而发送通知的模块事实上不需要知道前者的存在时。
在上述情况满足的情况下，为了降低对象之间的耦合度，我们引入Observer来实现我们的目标。
从稳定-变化的角度来分析的话，使用Observer的程序，接受者获取通知的方式是稳定的，而发送者和接收者可以随时变化。

模式应用
观察者模式在软件开发中应用非常广泛，如某电子商务网站可以在执行发送操作后给用户多个发送商品打折信息，某团队战斗游戏中某队友牺牲将给所有成员提示等等，凡是涉及到一对一或者一对多的对象交互场景都可以使用观察者模式

代码实现

subject

#ifndef SUBJECT_H
#define SUBJECT_H
#include "Observer.h"
class Subject{
public:
    virtual void registerObserver(Observer *o)=0;
    virtual void removeObserver(Observer *o)=0;
    virtual void notifyObservers()=0;
    virtual ~Subject(){};
};

#endif // SUBJECT_H

ConcreteSubject 即WeatherData类
ConcreteSubject.h

#include "Subject.h"
#include "Observer.h"
#include 
using std::vector;
class WeatherData:public Subject{
public:
    WeatherData();
    virtual void registerObserver(Observer *o)override final;
    virtual void removeObserver(Observer *o)override final;
    virtual void notifyObservers()override final;
    void measurementsChanged();
    void setMeasurements(float temperature,float humidity,float pressure);

    virtual ~WeatherData();
private:
    vector<Observer *> observers;
    float temperature;
    float humidity;
    float pressure;
};

ConcreteSubject.cpp

void WeatherData::registerObserver(Observer *o)
{
    observers.push_back(o);
}

void WeatherData::removeObserver(Observer *o)
{
    if(observers.size()!=0){
        for(auto it=observers.begin();it!=observers.end();it++){
            if(*it==o){
                observers.erase(it);
                break;
            }
        }
    }
}

void WeatherData::notifyObservers()
{
    for(auto it=observers.begin();it!=observers.end();it++){
        (*it)->update(temperature,humidity,pressure);
    }
}

void WeatherData::measurementsChanged()
{
    notifyObservers();
}

void WeatherData::setMeasurements(float temperature, float humidity, float pressure)
{
    this->temperature=temperature;
    this->humidity=humidity;
    this->pressure=pressure;
    measurementsChanged();
}

observer类

class Observer{
public:
    virtual void update(float temperature,float humidity,float pressure)=0;
    virtual ~Observer(){};
};

....
class DisplayElement{
public:
    virtual void display()=0;
    virtual ~DisplayElement(){};
};

ConcreteObserver.h

class CurrentConditionsDisplay:public DisplayElement,public Observer{
public:
    CurrentConditionsDisplay(Subject *weatherData);
    virtual void update(float temperature,float humidity,float pressure)override final;
    virtual void display()override final;
    virtual ~CurrentConditionsDisplay();
private:
    float temperature;
    float humidity;
    Subject *weatherData;
};

ConcreteObserver.cpp

CurrentConditionsDisplay::CurrentConditionsDisplay(Subject *weatherData)
{
    this->weatherData=weatherData;
    weatherData->registerObserver(this);
}

void CurrentConditionsDisplay::update(float temperature, float humidity, float pressure)
{
    this->temperature=temperature;
    this->humidity=humidity;
    display();
}

void CurrentConditionsDisplay::display()
{
    cout<<"Current conditions: "<<temperature<<"F degrees and "<<humidity<<"% humidity"<<endl;
}

main.cpp

 	WeatherData *weatherData = new WeatherData();

    CurrentConditionsDisplay *currentDisplay =  new CurrentConditionsDisplay(weatherData);
    StatisticsDisplay *statisticsDisplay = new StatisticsDisplay(weatherData);
    ForecastDisplay *forecastDisplay = new ForecastDisplay(weatherData);

    weatherData->setMeasurements(80, 65, 30.4f);
    weatherData->setMeasurements(82, 70, 29.2f);
    weatherData->setMeasurements(78, 90, 29.2f);

    weatherData->removeObserver(forecastDisplay);
    weatherData->setMeasurements(62, 90, 28.1f);

类图结构

模式分析：

观察者模式描述了如何建立对象与对象之间的依赖关系，如何构造满足这种需求的系统。
这一模式中的关键对象是观察目标和观察者，一个目标可以有任意数目的与之相依赖的观察者，一旦目标的状态发生改变，所有的观察者都将得到通知。
作为对这个通知的响应，每个观察者都将即时更新自己的状态，以与目标状态同步，这种交互也称为发布-订阅(publishsubscribe)。目标是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅它并接收通知。