设计模式-观察者模式

观察者模式介绍：

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

举例：地雷战：敌人来了，哨兵（Asubject被观察者）先观察到，然后哨兵通知村名转移、游击队阻击、工兵埋地雷(Bobserver观察者)。

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

A与B的关系：B的变化直接导致A的变化，因为A依赖一个B的具体对象，强耦合，造成软件很难灵活抵御需求带来的变化与更改。

但是如果地下党的同志来了，就不需要通知村民了。解决：依赖倒转，面向接口编程。不要依赖一个对象，去依赖一个抽象或接口。

对通知（依赖）目标对象进行抽象。乡亲与游击队的函数可能差别很大（名字、参数），但是一点，他们的功能是一样的，就是对鬼子进村做出相应反应。——>抽象

依赖抽象，使得结构耦合度降低

哨兵有明哨、暗哨、连环哨.....

解决：抽象哨兵，一个对象不稳定，一定要去把对象分出稳定部分或者不稳定部分。

此次示例介绍：Army、Villeger继承于Observer,     SubjectA、SubjectB继承于Subject。

Army、Villeger中有一个Subject对象指针用于观察，m_pSubject在构造函数中初始化。

SubjectA、SubjectB中有一个Observer list用于存储待通知的观察者，当自身状态发生改变时，就通知与自己关联的每一个观察者。

主入口.cpp

#include"Army.h"
#include"Observer.h"
#include"Villeger.h"
#include"Subject.h"
#include"SubjectA.h"
#include"SubjectB.h"
#include<iostream>
using namespace std;
int main()
{
	// Create Subject
	SubjectA *pSubject = new SubjectA();//哨兵一号（敌人来了负责通知村民、民兵）
	SubjectB *pSubject2 = new SubjectB();//哨兵二号（地下党来了负责通知民兵）

	// Create Observer
	Observer *pObserver = new Villeger(pSubject);//村名观察者
	Observer *pObserver2 = new Army(pSubject);//民兵观察者

	// Change the state
	int state;//1.敌人来了，2.敌人撤退了，3.地下党同志来了，4.地下党同志走了
	while (cin>>state)
	{
		pSubject->setState(state);//改变哨兵状态
		pSubject2->setState(state);
		switch (state)
		{
		case 1:
			//添加观察者（民兵，村民）
			pSubject->attach(pObserver);
			pSubject->attach(pObserver2);
			pSubject->notify();
			break;
		case 2:
			pSubject->notify();
			//删除观察者（民兵，村民）
			pSubject->detach(pObserver);
			pSubject->detach(pObserver2);
			break;
		case 3:
			//添加观察者（民兵）
			pSubject2->attach(pObserver2);
			pSubject2->notify();
			break;
		case 4:
			//删除观察者（民兵）
			pSubject2->notify();
			pSubject2->detach(pObserver2);
			break;
		default:break;
		}
		
	}
	pSubject=NULL;
	pSubject2 = NULL;
	pObserver = NULL;
	pObserver2=NULL;
	delete pObserver;
	delete pObserver2;
	delete pSubject;
	delete pSubject2;
}

其他类设计：

1.Observer类

class Observer
{
public:
	Observer();
	~Observer();
	virtual void update(int state) = 0;

};

2.Villeger和army类

#pragma once
#include "Observer.h"
#include"Subject.h"
class Villeger :
	public Observer
{
public:
	Villeger(Subject *subject)
        {
	    m_pSubject = subject;
        }
	~Villeger();
	void update(int state)
        {
	    // TODO: 在此处添加实现代码.
	    cout << "村民状态发生改变：" << state << endl;
        }
protected:
	Subject *m_pSubject;
};

#pragma once
#include"Observer.h"
#include"Subject.h"
class Army:
public Observer 
{
public:
	Army(Subject *subject)
        {
	    m_pSubject = subject;
        }
	~Army();
	void update(int state)
        {
	    cout << "军队准备,状态改变：" << state << endl;
        }
protected:
	Subject *m_pSubject;
};

3.Subject类

#pragma once

class Observer
{
public:
	Observer();
	~Observer();
	virtual void update(int state) = 0;

};

4.SubjectA 、SubjectB类设计都是一样的。

#pragma once
#include "Subject.h"
#include<list>
class SubjectA :
	public Subject
{
public:
	SubjectA();
	~SubjectA();
    	void detach(Observer *pObeserver)
        {
	    m_Observerlist.remove(pObeserver);
        }

	void attach(Observer *pObeserver)
        {
	    m_Observerlist.push_back(pObeserver);   
        }

	void notify()
        {
	    std::list<Observer *>::iterator it = m_Observerlist.begin();
	    while (it != m_Observerlist.end())
	    {
		(*it)->update(m_state);
		++it;
	    }
        }

	void setState(int state)
	{
		m_state = state;

	}
protected:
	int m_state;
	std::list<Observer *>  m_Observerlist;
	

};

5.运行结果