放哨——观察者模式

观察者模式

观察者模式UML

观察者模式是一种对象行为模式。它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

#pragma once
#include <iostream>
#include <vector>
#include <string>
#include <Windows.h>

using namespace std;

//抽象观察者
class Observer
{
public:
	virtual void Update() = 0;		//更新状态
	virtual void lastAction() = 0;  //一般动作
};

//观察者A
class Observer_A : public Observer
{
public:
	virtual void Update(){ cout << "赶紧装着认真学习" << endl;}
	virtual void lastAction(){ cout << "老师不再我就玩手机" << endl;}
};

//观察者B
class Observer_B : public Observer
{
public:
	virtual void Update(){ cout << "赶紧装着认真学习" << endl;}
	virtual void lastAction(){ cout << "老师不再我就吃东西" << endl;}
};

//被观察者（放哨的）
class Subject
{
public:
	//订阅
	void subscribe(Observer* object)
	{
		save.push_back(object);
	}

	//删除
	void destroy(Observer* object)
	{
		vector<Observer*>::iterator iter = save.begin();
		for(iter; iter != save.end(); iter++)
		{
			if(*iter == object)
			{
				save.erase(iter);
				break;
			}
		}
	}
	
	//更新(放哨的提醒)
	void Notity()
	{
		vector<Observer*>::iterator iter = save.begin();
		for(iter; iter != save.end(); iter++)
		{
			(*iter)->Update();
		}
	}

	//一般情况
	void Normal()
	{
		vector<Observer*>::iterator iter = save.begin();
		for(iter; iter != save.end(); iter++)
		{
			(*iter)->lastAction();
		}
	}

private:
	vector<Observer*> save;
};

//具体的被观察者（具体的放哨）
class Keep_watch : public Subject
{
public:
	Keep_watch(string str):name(str){ cout << "放哨的:" << name << endl;}
private:
	string name;
};

int main()
{
	Observer_A xiaoming;
	Observer_B xiaogang;
	Keep_watch xiaohong("小红");

	xiaohong.subscribe(&xiaoming);
	xiaohong.subscribe(&xiaogang);

	bool state = true;

	for(int i = 0; i<2; i++)
	{
		if(state)
		{
			cout << "老师不在"<< endl;
			xiaohong.Normal();
			state = false;
		}
		else
		{
			cout << "老师回来了"<< endl;
			xiaohong.Notity();
		}
	}

	system("pause");
	return 1;
}

使用场景

1、当一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
2、当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象需要被改变。
3、当一个对象必须通知其他对象，而它又不能假定其他对象是谁。换言之，不希望这些对象是紧密耦合的。

优点

观察者模式解除了主题和具体观察者的耦合，让耦合的双方都依赖于抽象，而不是依赖具体。