设计模式-行为-观察者

#pragma once

#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 指针的链表 
}; 

// ConcreateSubject 类,派生在Subject 类 
class ConcreateSubject : public Subject 
{ 
public: 
	ConcreateSubject() : Subject(){} 
	virtual ~ConcreateSubject(){} 

	// 派生类自己实现来覆 基类的实现 
	virtual void   SetState(STATE nState);     // 设置状态 
	virtual STATE    GetState();       // 得到状态 
}; 

//订阅者
// Observer 抽象基类 
class Observer 
{ 
public: 
	Observer() : m_nObserverState(-1){} 
	virtual ~Observer(){} 

	// 纯虚函数,各个派生类可能有不同的实现 
	// 通知Observer 状态发生了变化 
	virtual void Update(Subject* pSubject) = 0; 

protected: 
	STATE m_nObserverState; // 模拟保存Observer 状态的变量 
}; 
// ConcreateObserver 类派生自Observer 
class ConcreateObserver : public Observer 
{ 
public: 
	ConcreateObserver() : Observer(){} 
	virtual ~ConcreateObserver(){} 

	// 虚函数,实现基类提供的接口 
	virtual void Update(Subject* pSubject); 
}; 

#endif 

#include "StdAfx.h"
#include "observer_impl.h"

#include <iostream> 
#include <algorithm> 
/* ---------------------- 
|   Subject 类成员函数的实现 
| 
-*/ 
void Subject::Attach(Observer *pObserver) 
{ 
	std::cout << "Attach an Observer:"<<pObserver<<std::endl; 
	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) 
	{ 
		std::cout << "Detach an Observer:"<<*iter<<std::endl; 
		m_ListObserver.erase(iter); 
	} 
} 

void Subject::Notify() 
{ 
	std::cout <<this<<" Notify Observers's State"<<std::endl; 
	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) 
{ 
	m_nSubjectState = nState; 
} 

STATE Subject::GetState() 
{ 
	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) 
{ 
	m_nSubjectState = nState; 
} 

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

/* ---------------------- 
|  ConcreateObserver 类成员函数的实现 
| 
-*/ 
void ConcreateObserver::Update(Subject* pSubject) 
{
	if (NULL == pSubject) 
		return; 
	m_nObserverState = pSubject->GetState(); 
	std::cout << "Observer:"<<this<<" GetState:" <<m_nObserverState << std::endl; 
} 

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

#include "stdafx.h"

#include "observer_impl.h"

int _tmain(int argc, _TCHAR* argv[])
{
	Observer *p1 = new ConcreateObserver; //订阅者1
	Observer *p2 = new ConcreateObserver; //订阅者2

	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;
}