Observer模式

　　观察者模式（有时又被称为发布/订阅模式）是软件设计模式的一种。在此种模式中，一个目标对象管理所有相依于它的观察者对象，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。

 

抽象目标类别

　　此抽象类别提供一个接口让观察者进行添附与解附作业。此类别内有个不公开的观察者串炼，并透过下列函数(方法)进行作业：

 

　　添附(Attach)：新增观察者到链表中，以追踪目标对象的变化。

　　解附(Detach)：将已经存在的观察者从串炼中移除。

　　通知(Notify)：利用观察者所提供的更新函式来通知此目标已经产生变化。

　　添附函数包涵了一个观察者对象参数。也许是观察者类别的虚函，或是在非面向对象的设定中所使用的函数。

 

目标类别

　　此类别提供了观察者欲追踪的状态。也利用其源类别(例如前述的抽象目标类别)所提供的方法,来通知所有的观察者其状态已经更新。此类别拥有以下函数：

 

　　取得状态(GetState)：回传该目标对象的状态。

 

抽象观察者接口

　　抽象观察者类别是一个必须被实做的抽象类别。这个类别定义了所有观察者都拥有的更新用接口，此接口是用来接收目标类别所发出的更新通知。此类别含有以下函数：

 

　　更新(Update)：会被实做的一个抽象函数。

 

观察者类别

　　这个类别含有指向目标类别的参考(reference)，以接收来自目标类别的更新状态。此类别含有以下函数：

 

　　更新(Update)：是前述抽象函式的实做。当这个函数被目标对象调用时，观察者对象将会调用目标对象的取得状态函数，获取所拥有的更新目标对象信息。

　　每个观察者类别都要实做它自己的更新函数，以应对状态更新的情形。

 

　　当目标对象改变时，会通过调用它自己的通知函数来将通知送给每一个观察者对象，这个通知函数则会去调用已经添附在链表内的观察者更新函数。通知与更新函数可能会有一些参数，好指明是目前目标对象内的何种改变。这样做将可增进观察者的效率(只更新那些改变部份的状态)。

 

 

 

 

/* Observer.h */

#ifndef  OBSERVER_H

#define  OBSERVER_H

#include 

typedef  int  STATE  ;

class  Observer  ;

// Subject抽象基类,只需要知道Observer基类的声明就可以了

class  Subject

{

public :

       Subject() : m_nSubjectState(-1){}

         virtual  ~Subject();

         void  Notify();  // 通知对象改变状态

         void  Attach(  Observer  *pObserver);  //新增对象

         void  Detach(  Observer  *pObserver);  //删除对象

         // 虚函数,提供默认的实现,派生类可以自己实现来覆盖基类的实现

         virtual  void  SetState(  STATE  nState);  // 设置状态

         virtual  STATE   GetState();  // 得到状态

protected :

         STATE  m_nSubjectState;  // 模拟保存Subject状态的变量

       std::  list <  Observer *> m_ListObserver;  // 保存Observer指针的链表

};

// Observer抽象基类

class  Observer

{

public :

       Observer() : m_nObserverState(-1){}

         virtual  ~Observer(){}

         // 纯虚函数,各个派生类可能有不同的实现

         // 通知Observer状态发生了变化

         virtual  void  Update(  Subject * pSubject) = 0;

protected :

         STATE  m_nObserverState;  // 模拟保存Observer状态的变量

};

// ConcreateSubject类,派生在Subject类

class  ConcreateSubject  :  public  Subject

{

public :

       ConcreateSubject() :  Subject (){}

         virtual  ~ConcreateSubject(){}

         // 派生类自己实现来覆盖基类的实现

         virtual  void  SetState(  STATE  nState);  // 设置状态

         virtual  STATE  GetState();  // 得到状态

};

// ConcreateObserver类派生自Observer

class  ConcreateObserver  :  public  Observer

{

public :

       ConcreateObserver() :  Observer (){}

         virtual  ~ConcreateObserver(){}

         // 虚函数,实现基类提供的接口

         virtual  void  Update(  Subject * pSubject);

};

#endif

/* Observer.cpp */

#include  "Observer.h"

#include 

#include 

/**//* --------------------------------------------------------------------

|　　　 Subject类成员函数的实现

|

　----------------------------------------------------------------------*/

void  Subject  ::Attach( Observer  * pObserver  )

{

       std::cout <<  "Attach an Observern" ;

       m_ListObserver.push_back(  pObserver );

}

void  Subject  ::Detach( Observer  * pObserver  )

{

       std::  list <  Observer *>::  iterator  iter;

       iter = std::find(m_ListObserver.begin(), m_ListObserver.end(),  pObserver );

         if  (m_ListObserver.end() != iter)

       {

              m_ListObserver.erase(iter);

       }

       std::cout <<  "Detach an Observern" ;

}

void  Subject  ::Notify()

{

       std::cout <<  "Notify Observers's Staten" ;

       std::  list <  Observer *>::  iterator  iter1, iter2;

         for  (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end();iter1 != iter2; ++iter1)

       {

              (*iter1)->Update(  this );

       }

}

void  Subject  ::SetState( STATE  nState )

{

       std::cout <<  "SetState By Subjectn" ;

       m_nSubjectState =  nState ;

}

STATE  Subject  ::GetState()

{

       std::cout <<  "GetState By Subjectn" ;

         return  m_nSubjectState;

}

Subject ::~Subject()

{

       std::  list <  Observer *>::  iterator  iter1, iter2, temp;

         for  (iter1 = m_ListObserver.begin(), iter2 = m_ListObserver.end();iter1 != iter2;)

       {

              temp = iter1;

              ++iter1;

                delete  (*temp);

       }

       m_ListObserver.clear();

}

/**//* --------------------------------------------------------------------

|　　　 ConcreateSubject类成员函数的实现

|

----------------------------------------------------------------------*/

void  ConcreateSubject  ::SetState( STATE  nState )

{

       std::cout <<  "SetState By ConcreateSubjectn"  ;

       m_nSubjectState =  nState ;

}

STATE  ConcreateSubject  ::GetState()

{

       std::cout <<  "GetState By ConcreateSubjectn"  ;

         return  m_nSubjectState;

}

/**//* --------------------------------------------------------------------

|　　　 ConcreateObserver类成员函数的实现

|

----------------------------------------------------------------------*/

void  ConcreateObserver  ::Update( Subject  *  pSubject  )

{

         if  (  NULL  ==  pSubject )

                return ;

       m_nObserverState =  pSubject ->GetState();

       std::cout <<  "The ObeserverState is "  << m_nObserverState << std::endl;

}

/* Main.cpp */

#include  "Observer.h"

#include 

int  main()

{

         Observer  *p1 =  new  ConcreateObserver ;

         Observer  *p2 =  new  ConcreateObserver ;

         Subject * p =  new  ConcreateSubject ;

       p->Attach(p1);

       p->Attach(p2);

       p->SetState(4);

       p->Notify();

       p->Detach(p1);

       p->SetState(10);

       p->Notify();

         delete  p;

       system(  "pause" );

         return  0;

}