使用场景：

当一个对象的状态发生变化，并且需要改变其它对象的时候；或者当应用中一些对象必须观察其它对象的时候可以使用观察者模式。

步骤：

1、抽象观察者，提供一个抽象接口：update，这个接口用来接收被观察者的消息

2、子类继承实现抽象观察者，重写update接口

3、抽象被观察者，内部维护一个观察者的list，提供添加和删除观察者的接口，同时提供notify抽象接口

4、子类继承实现抽象观察者，重写notify接口 ：遍历观察者的list，调用每一个观察者的update接口

5、（可有可无）抽象观察者内部也可以维护一个被观察者的指针，在构造函数中就可以将当前观察者注册到这个被观察者中，不用在外部调用注册接口了
 

//被观察者 前置声明
class  AbstractNotifier;//下面的这些类都需要分.h.cpp文件编写，否则下面抽象被观察者调用接口会识别不到 编译不通过

//1、抽象观察者
class AbstractObserver {

public:
	AbstractObserver(AbstractNotifier* notifier) :mNotifier(notifier)
	{
		//构造函数中将当前观察者注册进被观察中
		mNotifier->registerObserver(this);
	}
	virtual ~AbstractObserver() = default;

	//反注册
	void unRegister()
	{
		mNotifier->unRegisterObserver(this);
	}

	//定义抽象接口：update接口
	virtual void update(string msg) = 0;
protected:
	//内部持有1个通知者的指针
	AbstractNotifier* mNotifier;
};

//2、观察者A
class ObserverA :public AbstractObserver
{
public:
	ObserverA(AbstractNotifier* notifier) :AbstractObserver(notifier)
	{
	}
	~ObserverA() = default;

	//3、重写对应接口
	void update(string msg) override
	{
		cout << "A观察者的更新动作" << msg;
	}
};

//观察者B
class ObserverB :public AbstractObserver
{
public:
	ObserverB(AbstractNotifier* notifier) :AbstractObserver(notifier)
	{
	}
	~ObserverB() = default;

	//4、重写对应接口
	void update(string msg) override
	{
		cout << "B观察者的更新动作" << msg;
	}
};


//---------------------------------------------------

//3、抽象被观察者
class AbstractNotifier
{
public:
	AbstractNotifier() = default;
	virtual ~AbstractNotifier() = default;


	//提供注册观察者的接口
	void registerObserver(AbstractObserver* observer)
	{
		observerList.push_back(observer);
	}
	//提供反注册的接口
	void unRegisterObserver(AbstractObserver* observer)
	{
		observerList.remove(observer);
	}
	//提供通知观察者的通知接口，子类对其重写，来通知不同的消息
	virtual void notify(string msg) = 0;


protected:
	//内部维护一个观察者的列表
	list<AbstractObserver*> observerList;
};

//被观察者E
class NotifierE :public AbstractNotifier
{
public:
	NotifierE() = default;
	~NotifierE() = default;

	//重写notify方法 通知具体的信息给每一个注册进来的观察者
	void notify(string msg) override
	{
		for (auto& itor : observerList)
		{
			itor->update(msg);
		}
	}

};

//被观察者F
class NotifierF :public AbstractNotifier
{
public:
	NotifierF() = default;
	~NotifierF() = default;

	//重写notify方法 通知具体的信息给每一个注册进来的观察者
	void notify(string msg) override
	{
		for (auto& itor : observerList)
		{
			itor->update(msg);
		}
	}

};



int main()
{
	//外部使用
	//创建被观察者
	NotifierE e;
	NotifierF f;

	//可以随意选择要观察的对象
	ObserverA a1(&e);//a1观察者  观察 e
	ObserverA a2(&f);//a2观察者 观察 f

	ObserverB b1(&e);//b1观察者  观察 e
	ObserverB b2(&f);//b2观察者  观察 f

	e.notify("我是被观察者e");
	f.notify("我是被观察者f");
	
	return 0;
}