观察者模式原理与C++实现

定义

观察者模式又叫发布-订阅模式。定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个目标对象。这个对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。主要角色如下：

• Subject：可以有任意多个观察者观察同一个目标，提供注册和删除观察者对象的接口。
• Observer：为那些在目标发生改变时需要获得通知的对象定义一个更新接口。
• ConcreteSubject：将有关状态存入concreteObserver对象，当状态发生改变时，向它的各个观察者发出通知。
• ConcreteObserver：维护一个指向ConcreteSubject对象的引用；存储有关状态；实现Observer的更新接口以使自身状态与目标的状态保持一致。

C++实现

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

class Observer {
public:
	virtual void update(int state) {}
};

class ConcreteObserver : public Observer {
private:
	int subjectState = -1;
public:
	virtual void update(int state) override{
		cout << "状态由" << subjectState << "更新为" << state << endl;
		subjectState = state; 
	}
};

class Subject {
public:
	virtual void attach(shared_ptr<Observer> o) {}
	virtual void detach(shared_ptr<Observer> o) {}
	virtual void notify() {}
	virtual void setState(int val) {}
};

class ConcreteSubject : public Subject {
private:
	int state;
	list<shared_ptr<Observer>> obs;
public:
	virtual void attach(shared_ptr<Observer> o) override {
		obs.emplace_back(o);
		cout << "添加了一个观察者!共" << obs.size() << "个" << endl;
	}
	virtual void detach(shared_ptr<Observer> o) override {
		obs.remove(o);
		cout << "删除了一个观察者!还剩" << obs.size() << "个" <<endl;
	}
	virtual void notify() override {
		for (auto& ob : obs) {
			ob->update(state);
		}
	}
	virtual void setState(int val) override {
		state = val;
	}
};

int main() {
	unique_ptr<Subject> sub(new ConcreteSubject);
	shared_ptr<Observer> ob1(new ConcreteObserver);
	shared_ptr<Observer> ob2(new ConcreteObserver);
	shared_ptr<Observer> ob3(new ConcreteObserver);
	sub->attach(ob1);
	sub->attach(ob2);
	sub->attach(ob3);
	//更新目标状态并发出通知
	sub->setState(404);
	sub->notify();
	//删除一个观察者
	sub->detach(ob2);
	//更新目标状态并发出通知
	sub->setState(200);
	sub->notify();
	return 0;
}

运行结果如下所示：

添加了一个观察者!共1个
添加了一个观察者!共2个
添加了一个观察者!共3个
状态由-1更新为404
状态由-1更新为404
状态由-1更新为404
删除了一个观察者!还剩2个
状态由404更新为200
状态由404更新为200

总结

观察者模式适用于以下场景：

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