Type: Behavioral

观察者模式：在对象间定义一对多的依赖关系，这样当一个对象改变状态时，自动通知更新依赖他的对象。

#include <iostream>
#include <list>

using namespace std;

typedef int STATE;

class Observer
{
public:
    virtual void update(STATE state) = 0;
};

class ConcreteObserver : public Observer
{
public:
    void update(STATE state){
        cout<<"Update Observer State:"<<state<<endl; 
        observerState = state; 
    };
private:
    STATE observerState; 
};

class Subject
{
public:
    virtual void notify();
    void attach(Observer *pObserver){
        m_ListObserver.push_back(pObserver);
    };
    void detach(Observer *pObserver){
        list<Observer*>::iterator iter;
        iter = find(m_ListObserver.begin(), m_ListObserver.end(), pObserver);
        if (m_ListObserver.end() != iter)
        {
            m_ListObserver.erase(iter);
        }
    };

protected:
    list<Observer*> m_ListObserver;
};

class ConcreteSubject : public Subject
{
public:
    void notify(){
        list<Observer*>::iterator list_it;
        for (list_it = m_ListObserver.begin(); list_it != m_ListObserver.end();
             ++list_it)
        {
            (*list_it)->update(subjectState);
        }
    };
    void setState(STATE state){
        subjectState = state;
    };
private:
    STATE subjectState;
};

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

    ConcreteSubject* p = new ConcreteSubject;
    p->attach(p1);
    p->attach(p2);
    p->setState(4);
    p->notify();

    p->detach(p1);
    p->setState(10);
    p->notify();
    system("pause");
    return 0;
}