设计模式_20 观察者模式（含 UML图 和 C++代码）

20 观察者模式

20.1 概念

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

20.2 结构

抽象主题（抽象被观察者）角色：把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除对象。
具体主题（具体被观察者）角色：将有关状态存入具体观察者对象。在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
抽象观察者角色：观察者的抽象类。定义了一个更新接口，使得在得到主题更改通知时更新自己。
具体观察者角色：实现抽象观察者定义的接口。在得到主题更改通知时更新自身状态。

20.3 实现

20.3.1 UML图

20.3.2 代码

ObserverAndSubject.h：

//ObserverAndSubject.h
#ifndef _OBSERVERANDSUBJECT_H_
#define _OBSERVERANDSUBJECT_H_

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

class Observer;

class Subject {
public:
	virtual void addObserver(Observer* observer) = 0;
	virtual void deleteObserver(Observer* observer) = 0;
	virtual void send(string message) = 0;
};

class ConcreteSubject : public Subject {
private:
	list<Observer*> observers;
public:
	void addObserver(Observer* observer);
	void deleteObserver(Observer* observer);
	void send(string message);
};

class Observer {
public:
	virtual void addSubject(Subject* subject) = 0;
	virtual void deleteSubject(Subject* subject) = 0;
	virtual void update(string message) = 0;
};

class ConcreteObserver : public Observer {
private:
	string name;
	list<Subject*> subjects;
public:
	ConcreteObserver(string name);
	void addSubject(Subject* subject);
	void deleteSubject(Subject* subject);
	void update(string message);
};

#endif

ObserverAndSubject.cpp：

#include"ObserverAndSubject.h"


void ConcreteSubject::addObserver(Observer* observer) {
	this->observers.push_back(observer);
}
void ConcreteSubject::deleteObserver(Observer* observer) {
	this->observers.remove(observer);
}
void ConcreteSubject::send(string message) {
	for (auto it : this->observers) {
		it->update(message);
	}
}

ConcreteObserver::ConcreteObserver(string name) {
	this->name = name;
}
void ConcreteObserver::addSubject(Subject* subject) {
	this->subjects.push_back(subject);
	subject->addObserver(this);
}
void ConcreteObserver::deleteSubject(Subject* subject) {
	this->subjects.remove(subject);
	subject->deleteObserver(this);
}
void ConcreteObserver::update(string message) {
	cout <<this->name <<' ' << message << endl;
}

main.cpp：

#include"ObserverAndSubject.h"

int main() {
	Subject* subjectOne = new ConcreteSubject();
	Subject* subjectTwo = new ConcreteSubject();
	Observer* observerOne = new ConcreteObserver("number23");
	Observer* observerTwo = new ConcreteObserver("17RuntimeError");
	observerOne->addSubject(subjectOne);
	observerTwo->addSubject(subjectOne);
	observerTwo->addSubject(subjectTwo);
	subjectOne->send("message One");
	cout << endl;
	subjectTwo->send("message Two");
	cout << endl;
	observerTwo->deleteSubject(subjectOne);
	subjectOne->send("message Three");
	cout << endl;
	return 0;
}

20.4 优缺点

20.4.1 优点

降低了主题和观察者之间的耦合关系，两者为抽象耦合关系。
被观察者发送通知，所有注册的观察者都会收到信息（广播机制）。

20.4.2 缺点

观察者非常多的时候，收到信息不完全同步。
如果被观察者有循环依赖，会成环。

20.5 使用场景

对象间存在一对多的关系，一个对象的改变会影响其他对象。
一个抽象模型有两个方面，其中一个依赖于另一个方面时。

return 设计模式概述;

返回设计模式概述