设计模式(二十二)观察者模式 C++

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

观察者模式所做的内容就是解耦

应用场景之一就是数据中心和多个业务单元的分离

实现方式就是每一个观察者都要保存一个被观察者的指针。

被观察者注册观察者指针，通过操作观察者指针达到和观察者通信的目的。

#include <iostream>
#include "string"
#include "list"
using namespace std;

class Secretary;

class Observer
{	
public:
	virtual void update(string&) = 0;
};

class PlayserObserver :public Observer//观察者
{
public:
	PlayserObserver(Secretary *secretary)
	{
		this->m_secretary = secretary;
	}

	void update(string& action)
	{
		cout << "action:" << action << endl;
		
	}

private:
	Secretary *m_secretary;
};

class Secretary
{
public:
	Secretary()
	{
		m_list.clear();
	}

	void Notify(string info)
	{
		//给所有的 观察者 发送 情报
		for (list<Observer *>::iterator it = m_list.begin();
			it != m_list.end(); it++)
		{
			(*it)->update(info);
		}
	}

	void setPlayserObserver(Observer *o)
	{
		m_list.push_back(o);
	}

private:
	list<Observer *> m_list;
};

void main()
{
	Secretary            *secretary = NULL;
	PlayserObserver        *po1 = NULL;
	PlayserObserver        *po2 = NULL;

	secretary = new Secretary;
	po1 = new PlayserObserver(secretary);
	po2 = new PlayserObserver(secretary);

	secretary->setPlayserObserver(po1);
	secretary->setPlayserObserver(po2);

	secretary->Notify("老板来了");
	secretary->Notify("老板走了");
	delete secretary;
	delete po1;
	delete po2;

	system("pause");
	return;
}

// demo 2

#include<list>
#include <string>
#include <iostream>

class IWorkerManager
{
public:

	virtual void OnCustom() = 0;
};

typedef std::list<IWorkerManager*> ListWorker;

class INotifyer
{
public:

	virtual void RegisterObserver(IWorkerManager *pWorkerManager) = 0;

	virtual void UnRegisterObserver(IWorkerManager *pWorkerManager) = 0;

	virtual void NotifyeObserver() = 0;
};

class DataControlModule :public INotifyer
{
public:
	DataControlModule::DataControlModule()
	{
	}

	DataControlModule::~DataControlModule()
	{
	}

	void DataControlModule::RegisterObserver(IWorkerManager *pWorkerManager)
	{
		m_listWorker.push_back(pWorkerManager);
	}
	void DataControlModule::UnRegisterObserver(IWorkerManager *pWorkerManager)
	{
		m_listWorker.remove(pWorkerManager);
	}
	void DataControlModule::NotifyeObserver()
	{
		ListWorker::iterator iterWorker = m_listWorker.begin();
		for (; iterWorker != m_listWorker.end(); iterWorker++)
		{
			IWorkerManager* pWorker = *iterWorker;

			pWorker->OnCustom();

			//(*iterWorker)->OnCustom();
		}

	}

	void DataControlModule::setNewData(const char* pszNewValue)
	{
		m_strData = pszNewValue;

		NotifyeObserver();
	}

	void DataControlModule::getNewData(std::string &strOutInfo)
	{
		strOutInfo = m_strData;
	}

private:

	ListWorker m_listWorker; // 观察者列表

	std::string m_strData;
};

class WorkerModule :public IWorkerManager
{
public:

	WorkerModule(DataControlModule* pData, const char*pszInfo)
		:m_pdata(pData), m_strInfo(pszInfo)
	{
	}

	~WorkerModule()
	{
	}

	void WorkerModule::OnCustom()
	{
		std::string strData;
		m_pdata->getNewData(strData);

		std::cout << " WorkerName:   " << m_strInfo.c_str() << std::endl;

		std::cout << "Got Data:  " << strData.c_str() << std::endl;
	}

private:

	DataControlModule* m_pdata;
	std::string m_strInfo;
};

int main()
{
	DataControlModule m_Data;
	WorkerModule m_worker1(&m_Data, "KAKA");
	WorkerModule m_worker2(&m_Data, "MESSE");
	WorkerModule m_worker3(&m_Data, "INZAGHI");

	m_Data.RegisterObserver(&m_worker1);
	m_Data.RegisterObserver(&m_worker2);
	m_Data.RegisterObserver(&m_worker3);

	m_Data.setNewData("Champion");
	system("pause");
	return 0;
}