设计模式之四-观察者模式

一 意图

它定义了一种一对多的依赖关系，当目标的状态发生改变时，所有的观察者都会得到通知而自动更新，不用实时的监控目标。

二 别名

observer，依赖（depends），发布-订阅（Publish-Subsciribe）

三 适用性

1 当一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这二者封装在独立的对象中，以使得它们可以各自相互独立的改变和复用。

2 当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象需要被改变时。

3 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之，你不希望这些对象是紧密耦合的。

四 结构

   

五 实现

.h

#ifndef __CLASS__H
#define __CLASS__H

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

class CSubject;

class CObserver
{
public:
	virtual void Update(CSubject* subject)=0;
	virtual ~CObserver(){};
};


class CSubject
{
public:
	void Attach(CObserver* observer);
	void Detach(CObserver* observer);
	void Modify();
	virtual ~CSubject(){};
	virtual string GetState()=0;
	virtual void SetState(const string&  state)=0;
private:
	list<CObserver* > m_observerList;
};

class CConcreteSubject:public CSubject
{
public:
	string GetState();
	void   SetState(const string&  state);
private:
	string m_state;
};

class CConcreteObserverA:public CObserver
{
public:
	void Update(CSubject* subject);
};

class CConcreteObserverB:public CObserver
{;
public:
	void Update(CSubject* subject);
};


class CConcreteObserverC:public CObserver
{
public:
	void Update(CSubject* subject);
};
#endif

 

.cpp

 

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

void CSubject::Attach(CObserver* observer)
{
	m_observerList.push_back(observer);
}

void CSubject::Detach(CObserver* observer)
{
	if(! m_observerList.empty() )
	{
		m_observerList.remove(observer);
	}
}

void CSubject::Modify()
{
	list<CObserver *>::iterator ite=m_observerList.begin();

	for(;ite!=m_observerList.end();ite++)
	{
		(*ite)->Update(this);
	}
}

string CConcreteSubject::GetState()
{
	return m_state;
}

void CConcreteSubject::SetState(const string& state)
{
	m_state=state;
}


void CConcreteObserverA::Update(CSubject* subject)
{
	string state=subject->GetState();

	if(state == "yes")
	{
		cout<<"CConcreteObserverA is ready!\n";
	}
}

void CConcreteObserverB::Update(CSubject* subject)
{
	string state=subject->GetState();

	if(state == "yes")
	{
		cout<<"CConcreteObserverB is ready!\n";
	}
}


void CConcreteObserverC::Update(CSubject* subject)
{
	string state=subject->GetState();

	if(state == "yes")
	{
		cout<<"CConcreteObserverC is ready!\n";
	}
}

 

client:

#include "class.h"

void main()
{
	CSubject* pSubject=new CConcreteSubject();
	CObserver* pA= new CConcreteObserverA();
	CObserver* pB=new CConcreteObserverB();
	CObserver* pC=new CConcreteObserverC();

	pSubject->Attach(pA);
	pSubject->Attach(pB);
	pSubject->Attach(pC);
	pSubject->Detach(pB);

	pSubject->SetState("yes");
	pSubject->Modify();

	delete pSubject;
	delete pA;
	delete pB;
	delete pC;
	
}