行为模式：观察者模式

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

适用性：

（1）一个对象改变时需要同时改变其它对象，但不知道具体有多少对象有待改变。

（2）一个对象时必须通知其它对象，又不能假定其它对象是谁，也就是说这些对象是松耦合的。

（3）对一个对象有多个方面，封装在独立的对象中，并且相互之间有依赖。

缺点

1．如果一个被观察者有很多直接或间接的观察者，通知所有观察者会花费很多时间。

2．如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃，要特别注意这一点。

3．如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。

4．虽然观察者知道所观察的对象发生了变化，但没有相应的机制使观察者知道所观察的对象是怎么发生变化的。

观察者模式C++实现

Observer.

#ifndef _OBSERVER_H_
#define _OBSERVER_H_
#include <string>
#include <list>
using namespace std;

class Subject
{
public:
    ~Subject();
    Subject();
    virtual void Notify();
    virtual void Attach(Observer*);
private: 
    string m_state; 
    <span style="color:#FF0000;">list<Observer*> m_lst;</span>
};

//这个类的实现根据具体情况定，这里并没有做什么
class ConcreteSubjectA : public Subject</span>
{
public: 
    ConcreteSubjectA();
    ~ConcreteSubjectA();
};

<span style="color:#3333FF;">class Observer
</span>{
public: 
     ~Observer(); 
     virtual void Update(Subject*)=0;
protected: 
     Observer();
};

class ConcreteObserverA : public Observer
{
public:
    ConcreteObserverA(); 
    ~ConcreteObserverA(); 
    virtual void Update(Subject*);
private: 
    string m_state;
};

class ConcreteObserverB : public Observer
{
public: 
    ConcreteObserverB(); 
    ~ConcreteObserverB();
    virtual void Update(Subject*);
private: 
    string m_state;
};

#endif

Observer.cpp

#include "Observer.h"
#include <iostream>
#include <algorithm>
using namespace std;

Observer::Observer(){}
Observer::~Observer(){}

ConcreteObserverA::ConcreteObserverA(){}
ConcreteObserverA::~ConcreteObserverA(){}
void ConcreteObserverA::Update(Subject* pSubject)
{
    this->m_state = pSubject->GetState();
}

ConcreteObserverB::ConcreteObserverB(){}
ConcreteObserverB::~ConcreteObserverB(){}
void ConcreteObserverB::Update(Subject* pSubject)
{
    this->m_state = pSubject->GetState();
}

Subject::Subject(){}
Subject::~Subject(){}
void Subject::Attach(Observer* pObserver)
{
    this->m_lst.push_back(pObserver);
}

void Subject::Notify()
{
    list<Observer*>::iterator iter = this->m_lst.begin();
    for(;iter != m_lst.end();iter++)
    {
        (*iter)->Update(this);
    }
}

ConcreteSubjectA::ConcreteSubjectA(){}
ConcreteSubjectA::~ConcreteSubjectA(){}

main.cpp

#include "Observer.h"
#include <iostream>
using namespace std;

int main()
{
    Observer* p1 = new ConcreteObserverA();
    Observer* p2 = new ConcreteObserverB();

    Subject* pSubject = new ConcreteSubjectA();
    pSubject->Attach(p1);
    pSubject->Attach(p2);
    pSubject->Notify();
    
    return 0;
}