设计模式学习-----观察者模式

观察者模式
GOOD：定义了一种一对多的关系，让多个（被）观察对象（公司员工）同时监听一个主题对象（秘书，通知者），主题对象（通知者）状态发生变化时，会通知所有的观察者，使它们能够更新自己。

扩展：观察者模式可细分为两张模式，一种是推送观察者模式，一种是拉取观察者模式。

一对多中，一的对象改变，在通知多的接口中一可以把自己的状态推送给多，即为推送观察者模式，这种模式耦合性比较低，因为一可以对多完全屏蔽自己的任何信息。

另一种就是在通知多的接口中不推送任何消息，只通知多自己的状态改变了，让每个多主动从一中拉取自己需要的数据，即为拉取观察者模式，这种模式在每个多中都需要能够访问到一的地址，但可避免推送观察者模式中推送状态重构时，每个多都需要修改的弊端。



转载请注明，文章来自：http://blog.csdn.net/windows_nt
示例：

#include <string>
#include <iostream>
#include <vector>
using namespace std;

class Secretary;
//看股票的同事类（观察对象，观察者）
class StockObserver
{
private:
	string name;
	Secretary* sub;
public:
	StockObserver(string strname,Secretary* strsub)
	{
		name=strname;
		sub=strsub;
	}
	void Update();
};
//秘书类（主题对象，通知者）
class Secretary
{
private:
	vector<StockObserver> observers;
public:
	string action;
	void Add(StockObserver ob)
	{
		observers.push_back(ob);
	}
	void Notify()
	{
		vector<StockObserver>::iterator p = observers.begin();
		while (p!=observers.end())
		{
			(*p).Update();
			p++;
		}
	}
};

void StockObserver::Update()
{
	cout<<name<<":"<<sub->action<<",不要玩股票了，要开始工作了"<<endl;
}

//客户端
int main()
{
	Secretary *p=new Secretary();  //创建通知者

	//观察者
	StockObserver *s1= new StockObserver("小李",p);
	StockObserver *s2 = new StockObserver("小赵",p);
	//加入通知队列
	p->Add(*s1);
	p->Add(*s2);
	//事件
	p->action="老板来了";
	//通知
	p->Notify();
	return 0;
}

#include <string>
#include <iostream>
#include <vector>
using namespace std;

class SecretaryBase;
//抽象观察者
class CObserverBase
{
protected:
	string name;
	SecretaryBase* sub;
public:
	CObserverBase(string strname,SecretaryBase* strsub)
	{
		name=strname;
		sub=strsub;
	}
	virtual void Update()=0;
};
//具体的观察者，看股票的
class StockObserver : public CObserverBase
{
public:
	StockObserver(string strname,SecretaryBase* strsub) : CObserverBase(strname,strsub)
	{
	}
	virtual void Update();
};

//具体观察者，看NBA的
class NBAObserver : public CObserverBase
{
public:
	NBAObserver(string strname,SecretaryBase* strsub) : CObserverBase(strname,strsub){}
	virtual void Update();
};

//抽象通知者
class SecretaryBase
{
public:
	string action;
	vector<CObserverBase*> observers;
public:
	virtual void Attach(CObserverBase* observer)=0;
	virtual void Notify()=0;
};

//具体通知者
class Secretary :public SecretaryBase
{
public:
	void Attach(CObserverBase* ob)
	{
		observers.push_back(ob);
	}
	void Notify()
	{
		vector<CObserverBase*>::iterator p = observers.begin();
		while (p!=observers.end())
		{
			(*p)->Update();
			p++;
		}
	}
};

void StockObserver::Update()
{
	cout<<name<<":"<<sub->action<<",不要玩股票了，要开始工作了"<<endl;
}
void NBAObserver::Update()
{
	cout<<name<<":"<<sub->action<<",不要看NBA了，老板来了"<<endl;
}

//客户端：
int main()
{
	SecretaryBase *p=new Secretary();  //创建观察者

	//被观察的对象
	CObserverBase *s1= new NBAObserver("小李",p);
	CObserverBase *s2 = new StockObserver("小赵",p);
	//加入观察队列
	p->Attach(s1);
	p->Attach(s2);
	//事件
	p->action="老板来了";
	//通知
	p->Notify();

	return 0;
}

智能化观察者模式，不用客户端手动把被观察者加入观察队列，但破坏了封装性，在多线程编程中会有很大的问题。

#include <string>
#include <iostream>
#include <vector>
using namespace std;

class CObserverBase;		//抽象观察者
//具体通知者
class Secretary
{
public:
	static vector<CObserverBase*> m_ObServerBase;
public:
	Secretary() {}
	virtual ~Secretary() {}
	static void Attach(CObserverBase* ob)
	{
		m_ObServerBase.push_back(ob);
	}
	static void Notify();
};

//抽象观察者
class CObserverBase
{
public:
	CObserverBase* m_pObserverBase;
public:
	CObserverBase() { m_pObserverBase = NULL; Connect(); }
	virtual CObserverBase::~CObserverBase() { Disconnect(); }
	void Connect()
	{
		if (m_pObserverBase) return;
		Secretary::Attach(this);
		m_pObserverBase = this;
	}
	void Disconnect() {}
	virtual void OnUpdate() {}
};

void Secretary::Notify()
{
	vector<CObserverBase*>::iterator p = m_ObServerBase.begin();
	while (p != m_ObServerBase.end())
	{
		(*p)->OnUpdate();
		p++;
	}
}

//具体的观察者，看股票的
class StockObserver : public CObserverBase
{
public:
	StockObserver(string strname,Secretary* strsub)
	{
	}
	virtual void OnUpdate();
};

//具体观察者，看NBA的
class NBAObserver : public CObserverBase
{
public:
	NBAObserver(string strname,Secretary* strsub) 
	{

	}
	virtual void OnUpdate();
};

void StockObserver::OnUpdate()
{
	cout<<"CBA:"<<"不要玩股票了，要开始工作了"<<endl;
}
void NBAObserver::OnUpdate()
{
	cout<<"NBA:"<<"不要看NBA了，老板来了"<<endl;
}

vector<CObserverBase*> Secretary::m_ObServerBase;
//客户端：
int main()
{
	 //创建观察者
	Secretary* p = new Secretary; 
	//被观察的对象
	NBAObserver *s1= new NBAObserver("小李",p);
	StockObserver *s2 = new StockObserver("小赵",p);
	//通知
	p->Notify();

	return 0;
}