Observer （C++实现）

// Observer.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <list>
#include <algorithm>

 

using namespace std;

 

typedef int STATE;

 

class 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;     
 list<Observer*> m_ListObserver; 
};

class Observer
{
public:
 Observer() : m_nObserverState(-1){}
 virtual ~Observer(){}

 virtual void Update(Subject* pSubject) = 0;

protected:
 STATE m_nObserverState;     
};

class ConcreateSubject
 : public Subject
{
public:
 ConcreateSubject() : Subject(){}
 virtual ~ConcreateSubject()
 {
   
 }

 virtual void SetState(STATE nState); 
  virtual STATE  GetState(); 

};

class ConcreateObserver : public Observer
{
public:
 ConcreateObserver() : Observer(){}
 virtual ~ConcreateObserver(){}

 virtual void Update(Subject* pSubject);
};

void Subject::Attach(Observer *pObserver)
{
  cout<<"Attach an Observer"<<endl;
  m_ListObserver.push_back(pObserver);
}

void Subject::Detach(Observer *pObserver)
{
 std::list<Observer*>::iterator iter;
 iter =find(m_ListObserver.begin(), m_ListObserver.end(), pObserver);
 if (m_ListObserver.end() != iter)
 {
  m_ListObserver.erase(iter);
  cout << "Detach an Observer"<<endl;
 }
 else
 {
  cout<<"No this Observer,so cannot detach it"<<endl;
 }
}

void Subject::Notify()
{
 cout<<"Notify  to all observers"<<endl;
 list<Observer*>::iterator iter;
 for (iter= m_ListObserver.begin();iter!= m_ListObserver.end();iter++)
 {
  (*iter)->Update(this);
 }
}

void Subject::SetState(STATE nState)
{
 m_nSubjectState = nState;
}

STATE Subject::GetState()
{
 return m_nSubjectState;
}

Subject::~Subject()
{

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

 for (iter= m_ListObserver.begin(); iter!= m_ListObserver.end();)
 {
  temp = iter;
  ++iter; 
  delete (*temp);
 }
 
 m_ListObserver.clear();
}

void ConcreateSubject::SetState(STATE nState)
{
 std::cout << "SetState By ConcreateSubject/n";
 m_nSubjectState = nState;
}

STATE ConcreateSubject::GetState()
{
 std::cout << "GetState By ConcreateSubject/n";
 return m_nSubjectState;
}
void ConcreateObserver::Update(Subject* pSubject)
{
 if (NULL == pSubject)
  return;

 m_nObserverState = pSubject->GetState();

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

int _tmain(int argc, _TCHAR* argv[])
{
 Observer *p1 = new ConcreateObserver();
 Observer *p2 = new ConcreateObserver();

 Subject* p = new ConcreateSubject();
 p->Attach(p1);
 p->Attach(p2);
 p->SetState(8);
 p->Notify();

 p->Detach(p1);
 p->SetState(10);
 p->Notify();

 delete p;
 return 0;
}