设计模式实现（十）--- 观察者模式（Observer）

观察者模式：顶一了一种一堆多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

观察者与通知者，你中有我，我中有你。为了降低偶尔，针对抽象进行抽象。将抽象类的指针或者引用作为成员变量，这样就可以充分的利用多态的性质。

观察者的特点：将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧耦合，这样会给维护、扩展和重用都带来不便。

而观察者模式的关键对象时主题Subject和观察者Observer，一个Subject可以有任意数目的依赖它的Observer，一旦Subject的状态发生了改变，所有的Observer都可以得到通知。Subject发出通知时它并不需要知道谁是它的观察者，也就是说，具体观察者是谁，它根本就不需要知道。

当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象有待改变时，应该考虑使用观察者模式。一个抽象模型有两个方面，其中一方面依赖于另一方面，这时用观察者模式可以讲着两者封装在独立的对象中使它们各自独立的改变和复用。

总的来说，观察者模式锁做的工作其实就是在接触耦合。让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。

观察者模式原型实现

#include <list>
#include <string>
#include <iostream>
using namespace std;
//Observer类，抽象观察者，为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者一般用一个抽象类或者一个接口实现。
//更新接口通常包含一个Update()方法，这个方法叫做更新方法。
class Observer
{
public:
	int id;
public:
	virtual void Update() = 0;
};
//Subject类，可翻译为主题或抽象通知者，一般用一个抽象类或者一个接口实现。它把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个借口，可以增加和删除观察者对象。
class Subject
{
public:
	list<Observer *> observers;
public:
	//增加观察者
	void Attach(Observer *observer)
	{
		observers.push_back(observer);
	}
	//移除观察者
	void Detach(Observer *observer)
	{
		list<Observer *>::iterator iter = observers.begin();
		while((*iter)->id != observer->id && iter != observers.end()){iter++;}
		if(iter!=observers.end())
			observers.erase(iter);
	}
	//通知
	void Notify()
	{
		list<Observer *>::iterator iter = observers.begin();
		for(;iter != observers.end();iter++)
		{
			(*iter)->Update();
		}
	}
	
};
//ConcreteSubject类，叫做具体主题或具体通知者，将有关状态存入具体观察对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个具体子类实现
class ConcreteSubject : public Subject
{
public:
	string subjectState;
};

//ConcreteObserver类，具体观察者，实现抽象观察者角色锁要求的更新接口，以便使本身的状态与主题的状态相协调。具体观察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。
class ConcreteObserver1 : public Observer
{
public:
	string name;
	string observerState;
	ConcreteSubject *subject;
public:
	ConcreteObserver1(ConcreteSubject *subject,string name)
	{
		this->subject = subject;
		this->name = name;
	}
public:
	void Update()
	{
		observerState = subject->subjectState;
		cout << "观察者1" << name << "的新状态是" << observerState << endl;
	}
};

class ConcreteObserver2 : public Observer
{
public:
	string name;
	string observerState;
	ConcreteSubject *subject;
public:
	ConcreteObserver2(ConcreteSubject *subject,string name)
	{
		this->subject = subject;
		this->name = name;
	}
public:
	void Update()
	{
		observerState = subject->subjectState;
		cout << "观察者2" << name << "的新状态是" << observerState << endl;
	}
};

客户端代码
int main()
{
	ConcreteSubject *s = new ConcreteSubject();
	s->Attach(new ConcreteObserver1(s,"X"));
	s->Attach(new ConcreteObserver1(s,"Y"));
	s->Attach(new ConcreteObserver2(s,"Z"));
	s->subjectState = "ABC";
	s->Notify();
	return 1;
}

观察者模式例子

//一个前台防止老板出去办事后回办公室，而办公室的同时都在打酱油的程序
#include <list>
#include <string>
#include <iostream>
using namespace std;
class Observer
{
public:
	int id;
	
public:
	virtual void Update() = 0;
};
//通知者接口
class Subject
{
public:
	string action;
	virtual void Attach(Observer *observer) = 0;
	virtual void Detach(Observer *observer) = 0;
	virtual void Notify() = 0;
};
//具体通知者，可以使前台，也可以使老板
class Boss : public Subject
{
public:
	list<Observer *> observers;
	
public:
	void Attach(Observer *observer)
	{
		observers.push_back(observer);
	}
	void Detach(Observer *observer)
	{
		observers.remove(observer);
	}
	void Notify()
	{
		list<Observer *>::iterator iter = observers.begin();
		for(;iter != observers.end();iter++)
		{
			(*iter)->Update();
		}
	}
};
//具体通知者---前台
class QianTai : public Subject
{
public:
	list<Observer *> observers;
public:
	void Attach(Observer *observer)
	{
		observers.push_back(observer);
	}
	void Detach(Observer *observer)
	{
		observers.remove(observer);
	}
	void Notify()
	{
		list<Observer *>::iterator iter = observers.begin();
		for(;iter != observers.end();iter++)
		{
			(*iter)->Update();
		}
	}
};

//观察者--股票观察者
class StockObserver : public Observer
{
public:
	string name;
	string observerState;
	Subject *subject;
public:
	StockObserver(string name,Subject *subject)
	{
		this->name = name;
		this->subject = subject;
	}
	void Update()
	{
		cout << subject->action << " ,"<< name << "关闭股票行情，继续工作！"<<endl;
	}
};
//观察者 NBA观察者
class NBAObserver : public Observer
{
public:
	string name;
	string observerState;
	Subject *subject;
public:
	NBAObserver(string name,Subject *subject)
	{
		this->name = name;
		this->subject = subject;
	}
	void Update()
	{
		cout << subject->action << " ,"<< name << "关闭NBA视频，继续工作！"<<endl;
	}
};

int main()
{
	Boss *huhansan = new Boss();
	QianTai *qiantai = new QianTai();
	StockObserver *tongshi1 = new StockObserver("周鑫",huhansan);
	NBAObserver *tongshi2 = new NBAObserver("周二鑫",huhansan);
	huhansan->Attach(tongshi1);
	huhansan->Attach(tongshi2);

	huhansan->action = "我胡汉三回来了！";
	huhansan->Notify();
	
	qiantai->Attach(tongshi1);
	qiantai->Attach(tongshi2);
	
	qiantai->Detach(tongshi2);
	qiantai->action = "老板回来了！";
	qiantai->Notify();
	return 1;
};