Observer Pattern

1.Observer模式要解决的问题为：建立一个一（Subject）对多（Observer）的依赖关系，并且做到当“一”变化的时候，依赖这个“一”的多也能够同步改变.

2.Observer Pattern 结构图

　　注：这里的目标Subject提供依赖于它的观察者Observer的注册（Attach）和注销（Detach）操作，并且提供了使得依赖于它的所有观察者同步的操作（Notify）。观察者Observer则提供一个Update操作，注意这里的Observer的Update操作并不在Observer改变了Subject目标状态的时候就对自己进行更新，这个更新操作要延迟到Subject对象发出Notify通知所有Observer进行修改（调用Update）。

3.实现

#ifndef _SUBJECT_H_
#define _SUBJECT_H_

#include <list>
#include <string> 
using namespace std;

typedef string State;
class Observer;

class Subject 
{ 
public: 
    virtual ~Subject();
    virtual void Attach(Observer* obv);
    virtual void Detach(Observer* obv);
    virtual void Notify();
    virtual void SetState(const State& st) = 0;
    virtual State GetState() = 0;
protected: 
    Subject();
private: 
    list<Observer* >* _obvs;
};

class ConcreteSubject:public Subject 
{ 
public: 
    ConcreteSubject();
    ~ConcreteSubject();
    State GetState();
    void SetState(const State& st);
protected:
private: 
    State _st;
};

#endif

#include "Subject.h" 
#include "Observer.h"
#include <iostream> 
#include <list> 

using namespace std;
typedef string state;

Subject::Subject() 
{ 
    //****在模板的使用之前一定要new，创建 
    _obvs = new list<Observer*>;
}
Subject::~Subject() 
{

}
void Subject::Attach(Observer* obv) 
{ 
    _obvs->push_front(obv); 
}
void Subject::Detach(Observer* obv) 
{ 
    if (obv != NULL)
        _obvs->remove(obv);
}
void Subject::Notify() 
{
    list<Observer*>::iterator it;
    it = _obvs->begin();
    for (;it != _obvs->end();it++) 
    { //关于模板和iterator的用法
        (*it)->Update(this); 
    } 
}
ConcreteSubject::ConcreteSubject()
{ 
    _st = ''; 
}
ConcreteSubject::~ConcreteSubject() 
{

} 
State ConcreteSubject::GetState() 
{ 
    return _st; 
}
void ConcreteSubject::SetState(const State& st) 
{ 
    _st = st; 
}

#ifndef _OBSERVER_H_ 
#define _OBSERVER_H_

#include "Subject.h"
#include <string> 

using namespace std;
typedef string State;

class Observer 
{ 
public: 
    virtual ~Observer();
    virtual void Update(Subject* sub) = 0;
    virtual void PrintInfo() = 0;
protected:
    Observer();
    State _st;
private:
};

class ConcreteObserverA:public Observer 
{ 
public: 
    virtual Subject* GetSubject(); 
    ConcreteObserverA(Subject* sub);
    virtual ~ConcreteObserverA();

    //传入Subject作为参数，这样可以让一个View属于多个的Subject。
    void Update(Subject* sub);

    void PrintInfo();
protected:
private: 
    Subject* _sub;
};

class ConcreteObserverB:public Observer 
{ 
public: 
    virtual Subject* GetSubject();
    ConcreteObserverB(Subject* sub);
    virtual ~ConcreteObserverB();

    //传入Subject作为参数，这样可以让一个View属于多个的Subject。
    void Update(Subject* sub);

    void PrintInfo();
protected:
private: 
    Subject* _sub;
};

#endif

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

Observer::Observer() 
{ 
    _st = '';
}
Observer::~Observer() 
{

} 
ConcreteObserverA::ConcreteObserverA(Subject* sub) 
{ 
    _sub = sub;
    _sub->Attach(this);
}
ConcreteObserverA::~ConcreteObserverA() 
{
    _sub->Detach(this);
    if (_sub != 0) 
    { 
        delete _sub;
    } 
}
Subject* ConcreteObserverA::GetSubject() 
{ 
    return _sub; 
}
void ConcreteObserverA::PrintInfo() 
{ 
    cout<<"ConcreteObserverA observer.... "<<_sub->GetState()<<endl; 
}
void ConcreteObserverA::Update(Subject* sub) 
{ 
    _st = sub->GetState();
    PrintInfo();
}
ConcreteObserverB::ConcreteObserverB(Subject* sub) 
{ 
    _sub = sub;
    _sub->Attach(this); 
}
ConcreteObserverB::~ConcreteObserverB() 
{ 
    _sub->Detach(this);
    if (_sub != 0) 
    { 
        delete _sub; 
    } 
}
Subject* ConcreteObserverB::GetSubject() 
{
    return _sub; 
}
void ConcreteObserverB::PrintInfo() 
{ 
    cout<<"ConcreteObserverB observer.... "<<_sub->GetState()<<endl; 
}
void ConcreteObserverB::Update(Subject* sub) 
{ 
    _st = sub->GetState();
    PrintInfo(); 
}

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

int main(int argc,char* argv[]) 
{ 
    ConcreteSubject* sub = new ConcreteSubject();
    Observer* o1 = new ConcreteObserverA(sub);
    Observer* o2 = new ConcreteObserverB(sub);
    sub->SetState("old");
    sub->Notify();
    sub->SetState("new"); //也可以由Observer调用
    sub->Notify();
    return 0; 
}