观察者模式（C++）

简述

       观察者定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发送改变时会通知所有观察者对象，使他们能够自动更新自己

适用场景

       当一个对象的改变需要同时改变其他对象的时候使用，一对多的关系。

       当一个对象模型有两方面，其中一方面以来另一方面，这时观察者模式可以将这两者封装在独立的对象中使他们各自独立的改变和复用。

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

UML类图

对象职责

Observer：抽象通知者，他把所有观察者对象的的引用保存到一个数组里，每个主题可以提供任何数量的观察者，通知者可以增加和删除观察者对象

ObserverEmployee：具体通知者，将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给所有观察者发出通知

Informer：抽象观察者，为所有具体观察者定义一个接口，在得到通知者发出的通知时更新自己

InformerReception：具体观察者，实现抽象的更新接口，以使自身的状态与主题的状态想协调

TargetBoss：观察目标，具体的主题对象，它的状态发生变化时可以影响所有的观察者对象。

代码实现

#include <stdio.h>
#include <vector>
#include <iostream>

//抽象观察者
class Observer
{
public:
	Observer(){}
	virtual void Update(int state) = 0;
private:
};

//具体观察者
class ObserverEmployee :public Observer
{
public:
	ObserverEmployee(std::string name)
	{
		mName = name;
	}

	void Update(int state)
	{
		if (state == 1)
		{
			std::cout << "boss回来了, " << mName.c_str() << "继续玩游戏" << std::endl;
		}
		else if (state == 2)
		{
			std::cout << "boss离开了，" << mName.c_str() << "开始工作" << std::endl;
		}
	}

private:
	std::string mName;
};

//观察目标
class TargetBoss
{
public:
	TargetBoss(std::string name, int state)
	{
		mName = name;
		mState = state;
	}

	void ChangeState(int state)
	{
		mState = state;
	}

	int GetState()
	{
		return mState;
	}
private:
	std::string mName;
	int mState;
};




//抽象通知者
class Informer
{
public:
	Informer()
	{
		mTargetBoss = NULL;
	}

	//加入
	virtual void Enroll(Observer* informer) = 0;
	//删除
	virtual void Eemove(Observer* informer) = 0;
	//通知
	virtual void notify() = 0;

	//观察目标
	virtual void SetTarget(TargetBoss *targetBoss) = 0;
	//目标状态
	virtual int GetTargetState() = 0;

	//观察者数组
	std::vector<Observer*> mInformerVector;
	//目标
	TargetBoss *mTargetBoss;
};

//具体通知者
class InformerReception : public Informer
{
public:
	InformerReception(){}

	//加入
	virtual void Enroll(Observer* informer)
	{
		if (informer != NULL)
		{
			mInformerVector.push_back(informer);
		}
	}
	//删除
	virtual void Eemove(Observer* informer)
	{

	}
	//通知
	virtual void notify()
	{
		for (int i = 0; i < mInformerVector.size(); i++)
		{
			mInformerVector[i]->Update(GetTargetState());
		}
	}

	//观察目标
	virtual void SetTarget(TargetBoss *targetBoss)
	{
		mTargetBoss = targetBoss;
	}
	//目标状态
	virtual int GetTargetState()
	{
		if (mTargetBoss == NULL)
		{
			return -1;
		}
		return mTargetBoss->GetState();
	}

private:
};


int main()
{
	TargetBoss *targetBoss = new TargetBoss("boss", 1);			//观察的目标

	Observer *objectZhang = new ObserverEmployee("张");		//观察者
	Observer *objectLi = new ObserverEmployee("李");

	Informer *informer = new InformerReception;			//通知者
	informer->Enroll(objectZhang);
	informer->Enroll(objectLi);
	informer->SetTarget(targetBoss);

	informer->notify();									//通知

	return 0;
}