设计模式--观察者模式

设计模式–观察者模式

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个对象，当被监听对象发生变化时，会通知所有观察者。

UML类图：

抽象目标作为基类，并依赖于一个抽象观察者。具体目标的Notify会通过抽象观察者调用具体观察者(ConcreteObserver)的update，达到通知观察者的目的。具体目标(ConscreteSubject)对象内部会维护一份观察患者名单，Attach\Detach增加或删除观察者。

具体目标和具体观察者需要继承抽象目标和查偶像观察者

具体观察者需要重写update，具体目标需要重写Notify/Attach/Detach

代码：

//Observer.h

#include "stdafx.h"
#include <iostream>
#include <list>

class AbstractObserver;

//抽象目标
class AbstractSubject 
{
public:
	virtual void Attach(AbstractObserver* ob) = 0;
	virtual void Detach(AbstractObserver* ob) = 0;
	virtual void Notify() = 0;
};

/*抽象观察者*/
class AbstractObserver 
{
public:
	virtual void Update(int v) = 0;
};


/*具体目标*/
class ConcreteSubject : public AbstractSubject 
{
public:
	void Attach(AbstractObserver* ob);
	void Detach(AbstractObserver* ob);
	void Notify();
	void SetState(int v) { subjectstete = v; }
private:
	int subjectstete;
	std::list<AbstractObserver*> Ob_list; //一个具体目标会有多个观察者，维护一份观察者名单,抽象基类指针从链表删除的时候注意
};


/*以下两个观察者是两个不同的类哦*/
/*具体观察者1*/
class ConcreteObserver_1 : public AbstractObserver
{
public:
	ConcreteObserver_1(AbstractSubject* absub) : m_subject(absub){}
	void Update(int v) { std::cout << "观察者1得知目标状态:" << v <<std::endl; }
private:

	AbstractSubject *m_subject;  //依赖一个抽象目标
};

/*具体观察者2*/
class ConcreteObserver_2 : public AbstractObserver
{
public:
	ConcreteObserver_2(AbstractSubject* absub) : m_subject(absub) {}
	void Update(int v) { std::cout << "观察者2得知目标状态:" << v <<std::endl; }
private:

	AbstractSubject *m_subject;  //依赖一个抽象目标
};

//Observer.cpp
#include "stdafx.h"
#include "Observer.h"



void ConcreteSubject::Attach(AbstractObserver * ob)
{
	Ob_list.push_back(ob);
}

void ConcreteSubject::Detach(AbstractObserver * ob)
{
	std::list<AbstractObserver*>::iterator it = Ob_list.begin();
	for (; it != Ob_list.end();) {
		if (*it == ob){
			it = Ob_list.erase(it);	
			std::cout << "删除一个"<<std::endl;
		}
		else{
			it++;
		}
	}
}

void ConcreteSubject::Notify()
{
	std::list<AbstractObserver*>::iterator it = Ob_list.begin();
	for (;it != Ob_list.end();it++){
		(*it)->Update(subjectstete);
	}
}


int main()
{
	//创建目标
	
	ConcreteSubject *p_subject = new ConcreteSubject;

	//创建观察者
	//父类指针指向子类对象
	//传参是要观察的具体目标
	AbstractObserver *p_observer = new ConcreteObserver_1(p_subject);
	AbstractObserver *p_observer2 = new ConcreteObserver_2(p_subject);

	//目标注册观察者
	p_subject->Attach(p_observer); 
	p_subject->Attach(p_observer2);

	//当目标发生变化
	p_subject->SetState(666);

	//通知所有观察者
	p_subject->Notify();

	p_subject->Detach(p_observer);
	p_subject->Detach(p_observer2);
	delete p_subject;
	delete p_observer;
	delete p_observer2;
	getchar();
    return 0;
}

结果：

参考文章：
https://www.cnblogs.com/carsonzhu/p/5770253.html