Observer模式

  观察者模式(有时又被称为发布/订阅模式)是软件设计模式的一种。在此种模式中,一个目标对象管理所有相依于它的观察者对象,并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。
 
抽象目标类别
  此抽象类别提供一个接口让观察者进行添附与解附作业。此类别内有个不公开的观察者串炼,并透过下列函数(方法)进行作业:
 
  添附(Attach):新增观察者到链表中,以追踪目标对象的变化。
  解附(Detach):将已经存在的观察者从串炼中移除。
  通知(Notify):利用观察者所提供的更新函式来通知此目标已经产生变化。
  添附函数包涵了一个观察者对象参数。也许是观察者类别的虚函,或是在非面向对象的设定中所使用的函数。
 
目标类别
  此类别提供了观察者欲追踪的状态。也利用其源类别(例如前述的抽象目标类别)所提供的方法,来通知所有的观察者其状态已经更新。此类别拥有以下函数:
 
  取得状态(GetState):回传该目标对象的状态。
 
抽象观察者接口
  抽象观察者类别是一个必须被实做的抽象类别。这个类别定义了所有观察者都拥有的更新用接口,此接口是用来接收目标类别所发出的更新通知。此类别含有以下函数:
 
  更新(Update):会被实做的一个抽象函数。
 
观察者类别
  这个类别含有指向目标类别的参考(reference),以接收来自目标类别的更新状态。此类别含有以下函数:
 
  更新(Update):是前述抽象函式的实做。当这个函数被目标对象调用时,观察者对象将会调用目标对象的取得状态函数,获取所拥有的更新目标对象信息。
  每个观察者类别都要实做它自己的更新函数,以应对状态更新的情形。
 
  当目标对象改变时,会通过调用它自己的通知函数来将通知送给每一个观察者对象,这个通知函数则会去调用已经添附在链表内的观察者更新函数。通知与更新函数可能会有一些参数,好指明是目前目标对象内的何种改变。这样做将可增进观察者的效率(只更新那些改变部份的状态)。
 
 Observer模式
 
 
Observer模式
/* Observer.h */
#ifndef OBSERVER_H
#define OBSERVER_H
#include <list>
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 <iostream>
#include <algorithm>
/**//* ——————————————————————–
|    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 <iostream>
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;
}