第十四章-观察者模式

观察者模式: 观察者模式又叫做发布-订阅(Publish/Subscribe)模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

基本代码

#include<iostream>
#include<string>
#include<vector>

using namespace std;

class Observer
{
public:
	virtual void Update() = 0;
};

class Subject
{
private:
	vector<Observer*> observers;

public:
	void Attach(Observer* observer_t)
	{
		observers.push_back(observer_t);
	}

	void Detach(Observer* observer_t)
	{
		for (auto _i = observers.begin(); _i != observers.end(); _i++)
		{
			if (*_i == observer_t)
			{
				observers.erase(_i);
				break;
			}				
		}
	}

	void Notify()
	{
		for (auto _i : observers)
			_i->Update();
	}

};

class ConcreteSubject : public Subject
{
private:
	string subjectState;

public:
	string get() { return subjectState; }
	void set(string subjectState_t) { subjectState = subjectState_t; }
};

class ConcreteObserver :public Observer
{
private:
	string name;
	string observerState;
	ConcreteSubject* subject;

public:
	ConcreteObserver(ConcreteSubject* subject_t, string name_t)
	{
		subject = subject_t;
		name = name_t;
	}

	void Update()
	{
		observerState = subject->get();
		cout << "观察者" << name << "的新状态时" << observerState << endl;
	}

	ConcreteSubject* get() { return subject; }
	void set(ConcreteSubject* subject_t) { subject = subject_t; }
};


int main()
{
	ConcreteSubject* s = new ConcreteSubject();

	s->Attach(new ConcreteObserver(s, "X"));
	s->Attach(new ConcreteObserver(s, "Y"));
	s->Attach(new ConcreteObserver(s, "Z"));

	s->set("ABC");
	s->Notify();

	system("pause");
	return 0;
}

老板回来了代码示例

#include<iostream>
#include<string>
#include<vector>

using namespace std;

class Subject;

class Observer
{
protected:
	string name;
	Subject* sub;
public:
	Observer(string name_t, Subject* sub_t)
	{
		name = name_t;
		sub = sub_t;
	}
	virtual void Update() = 0;
};

class Subject
{
public:
	string subjectState;
	virtual void Attach(Observer* observer_t) = 0;
	virtual void Detach(Observer* observer_t) = 0;
	virtual void Notify() = 0;
	virtual string getsubjectState() = 0;
	virtual void setsubjectState(string subjectState_t) = 0;

};

class Boss :public Subject
{
private:
	vector<Observer*> observers;
	string action;

public:
	void Attach(Observer* observer_t)
	{
		observers.push_back(observer_t);
	}

	void Detach(Observer* observer_t)
	{
		for (auto _i = observers.begin(); _i != observers.end(); _i++)
		{
			if (*_i == observer_t)
			{
				observers.erase(_i);
				break;
			}
		}
	}

	void Notify()
	{
		for (auto _i : observers)
			_i->Update();
	}

	string getsubjectState() { return subjectState; }
	void setsubjectState(string subjectState_t) { subjectState = subjectState_t; }
};

class Secretary :public Subject
{
private:
	vector<Observer*> observers;
	string action;

public:
	void Attach(Observer* observer_t)
	{
		observers.push_back(observer_t);
	}

	void Detach(Observer* observer_t)
	{
		for (auto _i = observers.begin(); _i != observers.end(); _i++)
		{
			if (*_i == observer_t)
			{
				observers.erase(_i);
				break;
			}
		}
	}

	void Notify()
	{
		for (auto _i : observers)
			_i->Update();
	}

	string getsubjectState() { return subjectState; }
	void setsubjectState(string subjectState_t) { subjectState = subjectState_t; }
};

class StockObserver :public Observer
{
public:
	StockObserver(string name_t, Subject* sub_t)
		: Observer(name_t, sub_t)
	{

	}

	void Update()
	{ 
		cout << sub->getsubjectState() << " " << name << " 关闭股票行情，继续工作！" << endl;
	}
};

class NBAObserver :public Observer
{
public:
	NBAObserver(string name_t, Subject* sub_t)
		: Observer(name_t, sub_t)
	{

	}

	void Update()
	{
		cout << sub->getsubjectState() << " " << name << " 关闭NBA直播，继续工作！" << endl;
	}
};



int main()
{
	Boss* huhansan = new Boss();
	StockObserver* tongshi1 = new StockObserver("魏", huhansan);
	NBAObserver* tongshi2 = new NBAObserver("易", huhansan);

	huhansan->Attach(tongshi1);
	huhansan->Attach(tongshi2);

	huhansan->Detach(tongshi1);

	huhansan->setsubjectState("我胡汉三回来了！");

	huhansan->Notify();


	system("pause");
	return 0;
}

观察者模式的特点

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

事件委托

....................