设计模式 -- 观察者模式

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

使用场景：当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象有待改变。耦合的双方依赖于抽象不是具体。

现实中的例子：

微博订阅，当订阅的主题有新消息发布时候，订阅者都会收到相应的通知；类似还有天气预报等

结构图：

C++代码：

//观察者模式
#include <iostream>
#include <list>

using namespace std;

class Observer;

//抽象主题或者抽象通知者类
class Subject {
public:
	//增加一个观察者
	virtual void attach(Observer *pObserver) = 0;
	//移除一个观察者
	virtual void detach(Observer *pObserver) = 0;
	//通知
	virtual void notify() = 0;
};

//抽象观察者：为所有的具体观察者定义一个更新自己的接口
class Observer {
public:
	virtual void update() = 0;
};

//具体主题类或者具体通知者
class ConcreteSubject : public Subject {
public:
	void attach(Observer *pObserver)
	{
		listObserver.push_back(pObserver);
	}
	void detach(Observer *pObserver)
	{
		listObserver.remove(pObserver);
	}
	void notify()
	{
		list<Observer*>::iterator iter;
		for(iter=listObserver.begin(); iter!=listObserver.end(); ++iter)
		{
			(*iter)->update();
		}
	}

	const string& getState() const {
		return state;
	}

	void setState(const string& state) {
		this->state = state;
	}

private:
	string state;
	list<Observer*> listObserver;
};

//具体观察者
class ConcreteObserver : public Observer {
public:
	ConcreteObserver(ConcreteSubject *cs, string n)
		: pSubject(cs), name(n)
	{}
	void update()
	{
		if(pSubject != NULL)
		{
			observerState = pSubject->getState();
			cout << name << "收到新通知 ： " << observerState << endl;;
		}
	}
private:
	ConcreteSubject *pSubject;
	string observerState;
	string name;
};



int main()
{
	ConcreteSubject *pCS = new ConcreteSubject();
	ConcreteObserver *pCO_one = new ConcreteObserver(pCS, "观察者1号");
	ConcreteObserver *pCO_two = new ConcreteObserver(pCS, "观察者2号");
	pCS->attach(pCO_one);
	pCS->attach(pCO_two);
	pCS->setState("主人要打dota啦...");
	pCS->notify();

	pCS->detach(pCO_two);
	pCS->notify();

	delete pCS;
	delete pCO_one;
	delete pCO_two;
	return 0;
}
/*
观察者观察者1号的新通知 ： 主人要打dota啦...
观察者观察者2号的新通知 ： 主人要打dota啦...
观察者观察者1号的新通知 ： 主人要打dota啦...
 */