观察者模式（c++实现）

一. 类图

Observable：接口（虚基类，没有成员变量），声明有“被观察者”通用的接口函数，像addObserver（添加“观察者”）, delObserver（删除“观察者”），notifyObserver（通知所有“观察者”）。

Observer：接口（虚基类，没有成员变量），每个“观察者”都含有“被观察者”Observable的指针，用来指向具体的“被观察者”，“观察者”调用“被观察者”的addObserver函数，成为其观察者。Observer接口类含有一个纯虚函数update，每个具体的“观察者”都要实现此函数，“被观察者”通过调用update来通知具体的观察者。

二. 代码实现

class Observer;

//被观察者接口
class Observable
{
public:
	Observable() {}
	virtual ~Observable() {}
	virtual void addObserver(string description, Observer* p) = 0;
	virtual void delObserver(string description) = 0;
	virtual void notifyObserver() = 0;
};

//观察者接口
class Observer
{
public:
	Observer(){}
	virtual ~Observer() {}
	virtual void update() = 0;
};

//被观察者A
class A : public Observable
{
public:
	A() {};
	~A() {};
	void addObserver(string description, Observer* p)
	{
		m_mapObserver.insert(pair<string, Observer*>(description, p));
	}
	void delObserver(string description)
	{
		m_mapObserver.erase(description);
	}
	void notifyObserver()
	{
		for_each(m_mapObserver.begin(),
			m_mapObserver.end(),
			[](const pair<string, Observer*> tmp) { tmp.second->update(); });
	}
private:
	map<string, Observer*> m_mapObserver;
};

//观察者B
class B : public Observer
{
public:
	B(string description, Observable* p) : m_description(description), m_pObservable(p){}
	~B() {};
	//注册成为A的观察者
	void registerToA()
	{
		m_pObservable->addObserver(m_description, this);
	}
	//移除对A的观察
	void unRegisterToA()
	{
		m_pObservable->delObserver(m_description);
	}
	void update()
	{
		cout << "I am " << m_description << ", get response from A." << endl;
	}
private:
	Observable* m_pObservable;
	string m_description;
};

//观察者C
class C : public Observer
{
public:
	C(string description, Observable* p) : m_description(description), m_pObservable(p) {}
	~C() {};
	//注册成为A的观察者
	void registerToA()
	{
		m_pObservable->addObserver(m_description, this);
	}
	//移除对A的观察
	void unRegisterToA()
	{
		m_pObservable->delObserver(m_description);
	}
	void update()
	{
		cout << "I am "<< m_description << ", get response from A." << endl;
	}
private:
	Observable* m_pObservable;
	string m_description;
};

int main(int argc, char* argv[])
{
	//定义一个被观察者
	A* pA = new A;

	//定义两个观察者,并注册成为A的观察者
	B* pB = new B("Observer B", pA);
	pB->registerToA();

	C* pC = new C("Observer C", pA);
	pC->registerToA();

	//调用A::notifyObserver通知A的所有观察者，这时候B和C都能收到响应。
	pA->notifyObserver();

	//B主动移除对A的观察
	pB->unRegisterToA();
	cout << "------------------------------------------------" << endl;

	//这时候再调用A::notifyObserver，只有C能收到响应。
	pA->notifyObserver();

	getchar();
	return 0;
}

运行结果图如下：