设计模式 --- 观察者模式（ Observer 模式 ）

监听者
处理事件
观察者
观察事件
通知感兴趣的监听者取处理事件

从定义上看：观察者模式 是当对象间存在一对多关系时，则使用观察者模式 ，比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式 属于 行为型模式。
其实，我所理解的 观察者模式 ，就是观察和被观察对象之间的关系，好比说，在拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。在这里面，拍卖师是观察者，而那些竞价者，是被观察者，文字不太好理解是吧，那我们画个图看一下：

从图中我们可以看到，拍卖师观察竞价者1的标价，拿到了最高标价，然后在通知其他竞价者，这就是一个简单的观察者模式图示，仔细看一下这个图，我们会发现，最基础的观察者模式中，涉及以下几种角色：

被观察者：竞价者们；
观察者：拍卖师；
具体的被观察者：竞价者们的出价动作；
具体的观察者：拍卖师观察竞价者的动作；

class Listener
{
public:
	Listener(std::string nm) :name(nm){}
	virtual void hanlemessege(int message)const = 0 ;
protected:
	std::string name;
};
class Listener1 : public Listener
{
public:
	Listener1(std::string name) :Listener(name){}
	void hanlemessege(int message)const
	{
		switch (message)
		{
		case 1:
			std::cout << name << " has been handle this " << message << "message" << std::endl;
			break;
		case 2:
			std::cout << name << " has been handle this " << message << "message" << std::endl;
			break;
		default:
			std::cout << " no interst this " << message << "message" << std::endl;
			break;
		}
	}
};
class Listener2 : public Listener
{
public:
	Listener2(std::string name) :Listener(name){}
	void hanlemessege(int message)const
	{
		switch (message)
		{
		case 2:
			std::cout << name << " has been handle this " << message << "message" << std::endl;
			break;
		case 3:
			std::cout << name << " has been handle this " << message << "message" << std::endl;
			break;
		default:
			std::cout << " no interst this " << message << "message" << std::endl;
			break;
		}
	}
};
class Listener3 : public Listener
{
public:
	Listener3(std::string name) :Listener(name){}
	void hanlemessege(int message)const
	{
		switch (message)
		{
		case 1:
			std::cout << name << " has been handle this " << message << "message" << std::endl;
			break;
		case 3:
			std::cout << name << " has been handle this " << message << "message" << std::endl;
			break;
		default:
			std::cout << " no interst this " << message << "message" << std::endl;
			break;
		}
	}
};

class Oberse
{
public:
	typedef std::map<int, std::vector<const Listener*>> MMAP;
	void registermessege(int message, const Listener* pl)
	{
		MMAP::iterator fit = mymap.find(message);
		if (fit != mymap.end())
		{
			fit->second.push_back(pl);
		}
		else
		{
			std::vector<const Listener*> vec;
			vec.push_back(pl);
			mymap.insert(std::pair<int, std::vector<const Listener*>>(message, vec));
		}
	}
	void notify(int message)
	{
		MMAP::iterator fit = mymap.find(message);
		if (fit != mymap.end())
		{
			std::vector<const Listener*>::iterator it = fit->second.begin();
			while (it != fit->second.end())
			{
				(*it)->hanlemessege(message);
				it++;
			}
		}
	}
public:
	std::map<int, std::vector<const Listener*>> mymap;
};
int main()
{
	Listener1 l1("listener1");
	Listener2 l2("listener2");
	Listener3 l3("listener3");

	Oberse ob;
	ob.registermessege(1, &l1);
	ob.registermessege(2, &l1);
	ob.registermessege(2, &l2);
	ob.registermessege(3, &l2);
	ob.registermessege(1, &l3);
	ob.registermessege(3, &l3);

	ob.notify(2);
	return 0;
}

总结一下：

从表面上看：
观察者模式里，只有两个角色 —— 观察者+被观察者
而发布订阅模式，却不仅仅只有发布者和订阅者两个角色，还有第三个角色-经纪人Broker存在。

往更深层次讲：
观察者和被观察者，是松耦合的关系；
发布者和订阅者，则完全不存在耦合。
其实我们在学习设计模式的时候，很多模式的实现，都是有一定依据的，首先离不开的就是面向对象三大特性，其次是面向对象七大原则，而设计模式则是对面向对象更具体的实现，我们学习这些模式的时候，还是要多去写代码实践一下，这些能有效的帮助我们优化代码。