设计模式——观察者模式

#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;

//观察者
class Observer
{
public:
	Observer(){};
	virtual ~Observer(){}

	virtual void Update() = 0;	
};

//被观察者
class Subject
{
public:
	Subject(){}
	virtual ~Subject(){}
	
	//添加观察泽
	void AddObserver(Observer *obj)
	{
		this->obs.push_back(obj);
	}
	
	//删除观察者
	void DeleteObsever(Observer *obj)
	{
		vector<Observer *>::iterator it;
		for(it=this->obs.begin();it!=this->obs.end();++it)
		{
			if(obj == *it)
			{
				this->obs.erase(it);
				//delete obj;
			}
		}
	}
	
	//通知观察者
	void NotifyObsever()
	{
		vector<Observer *>::iterator it;
		for(it=this->obs.begin();it!=this->obs.end();++it)
		{
			Observer *obj = *it;
			obj->Update();
		}
	}
	
	void Change()
	{
		NotifyObsever();
	}
	
private:
	vector<Observer*> obs;	
};



class ObserverA:public Observer
{
public:
	ObserverA(){};
	virtual ~ObserverA(){}	
	
	void Update()
	{
		printf("I'm observer A ,updated\n");
	}
};

class ObserverB:public Observer
{
public:
	ObserverB(){};
	virtual ~ObserverB(){}	
	
	void Update()
	{
		printf("I'm observer B ,updated\n");
	}
};

int main()
{
	Subject s;
	ObserverA a;
	ObserverB b;
	s.AddObserver(&a);
	s.AddObserver(&b);
	s.Change();
}

定义：

定义了算法族，分别封装起来，让他们之间互相替换，此模式让算法的变化独立于使用算法的客户

设计原则：

1、找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起

2、针对接口编程，而不是针对实现编程

3、多用组合，少用继承

适用性：

1、许多相关的类仅仅是行为有异，策略模式提供了一种用多个行为中的一个行为来配置一个类的方法。即一个系统需要动态的在几种算法中选择一种

2、需要使用一个算法的不同变体。例如，你可能会定义一些反映不同的空间/时间权衡的算法，当这些变体实现为一个算法的类层次时，可以使用策略模式

3、算法使用客户不应知道的数据，可以使用策略模式避免暴露复杂的，与算法相关的数据结构

4、一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入他们格式的类中代替这些条件语句

实现：

1、定义所有支持算法的公共接口

2、继承接口类，实现具体的算法

3、维护一个对公共接口对象的引用，用该引用来调用具体的算法