观察者模式（C++实现）

观察者模式：定义了一种一对多的依赖关系,让多个观察者对象同时监听某一主题对象,在它的状态发生变化时,会通知所有的观察者.

优点：

①观察者和被观察者是抽象耦合的。

②建立一套触发机制。

缺点：

①如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

②如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。

③观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。
 

观察者模式的一个实例 Model/View/Control（ MVC） 结构在系统开发架构设计中有着很重要的地位和意义， MVC实现了业务逻辑和表示层的解耦。 

MVC要求业务逻辑模型(Model)独立于于用户界面（View，视图，就是表示层），控制器（Controller）接收用户输入并协调两者，MVC支持应用程序的功能模块化，

并具有以下优点：

（1）模型和视图组件的隔离，就可以实现多套用户界面，并且使这些界面能够重用公共的业务逻辑核心。

（2）避免了因为多份UI实现而构建多份重复的底层模型代码的问题。

（3）模型和视图代码的解耦简化了为了核心业务逻辑代码编写单元测试工作。

（4）组件的模块化允许核心逻辑开发者和GUI开发者并行工作，且互不影响。

 

观察者模式角色如下：
抽象主题（Subject）角色：抽象主题角色提供维护一个观察者对象聚集的操作方法，对聚集的增加、删除等。
具体主题（ConcreteSubject）角色：将有关状态存入具体的观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色负责实现抽象主题中聚集的管理方法。
抽象观察者（Observer）角色：为具体观察者提供一个更新接口。
具体观察者（ConcreteObserver）角色：存储与主题相关的自洽状态，实现抽象观察者提供的更新接口。

UML图：

Observer 模式要解决的问题为： 建立一个一（ Subject）对多（ Observer） 的依赖关系， 并且做到当“一” 变化的时候， 依赖这个“一”的多也能够同步改变。

例子源码

Subject.h

#pragma once
#include <list>

class Observer;

// 抽象主题类
class Subject
{
public:
	Subject();
	virtual ~Subject();

public:
	virtual void Attach(Observer* pObserver);
	virtual void Detach(Observer* pObserver);
	virtual void Notify();

protected:
	std::list<Observer*> m_Observers;
};

// 具体主题类
class ConcreteSubject : public Subject
{
public:
	ConcreteSubject();
	ConcreteSubject(std::string name, std::string status);
	~ConcreteSubject();

public:
	void SetName(std::string name);
	std::string GetName();

	void SetStatus(std::string status);
	std::string GetStatus();

protected:
	std::string m_name;
	std::string m_status;
};

Subject.cpp

#include "Subject.h"
#include "Observer.h"

Subject::Subject()
{
}

Subject::~Subject()
{
}

void Subject::Attach(Observer* pObserver)
{
	if (pObserver)
	{
		m_Observers.push_back(pObserver);
	}
}

void Subject::Detach(Observer* pObserver)
{
	m_Observers.remove(pObserver);
}

void Subject::Notify()
{
	for (auto observer : m_Observers)
	{
		observer->Update(this);
	}
}


ConcreteSubject::ConcreteSubject()
{

}

ConcreteSubject::ConcreteSubject(std::string name, std::string status)
{
	m_name = name;
	m_status = status;
}

ConcreteSubject::~ConcreteSubject()
{

}

void ConcreteSubject::SetName(std::string name)
{
	m_name = name;
}

std::string ConcreteSubject::GetName()
{
	return m_name;
}

void ConcreteSubject::SetStatus(std::string status)
{
	m_status = status;
}

std::string ConcreteSubject::GetStatus()
{
	return m_status;
}

Observer.h

#pragma once
#include <string>

class Subject;

// 抽象观察者类
class Observer
{
public:
	Observer();
	virtual ~Observer();

public:
	virtual void Update(Subject*) = 0;
};

// 具体观察者类
class ConcreteObserver : public Observer
{
public:
	ConcreteObserver();
	ConcreteObserver(std::string name);
	~ConcreteObserver();

public:
	void SetName(std::string name);
	std::string GetName();
	void Update(Subject* pSubject);

protected:
	std::string m_name;
};

Observer.cpp

#include "Observer.h"
#include "Subject.h"
#include <iostream>

Observer::Observer()
{
}

Observer::~Observer()
{
}


ConcreteObserver::ConcreteObserver()
{

}

ConcreteObserver::ConcreteObserver(std::string name)
{
	m_name = name;
}

ConcreteObserver::~ConcreteObserver()
{

}

void ConcreteObserver::SetName(std::string name)
{
	m_name = name;
}

std::string ConcreteObserver::GetName()
{
	return m_name;
}

void ConcreteObserver::Update(Subject* pSubject)
{
	auto pSub = dynamic_cast<ConcreteSubject*>(pSubject);
	if (pSub)
	{
		std::cout << "【" << m_name << "】观察到【" << pSub->GetName() << "】状态为【" << pSub->GetStatus() << "】" << std::endl;
	}
}

main.cpp

#include "Subject.h"
#include "Observer.h"

int main()
{
	ConcreteSubject subject("默认主题", "默认状态");
	ConcreteObserver observer1("观察者1");
	ConcreteObserver observer2("观察者2");

	subject.Attach(&observer1);
	subject.Attach(&observer2);
	subject.Notify();

	subject.SetStatus("状态1");
	subject.Notify();

	subject.Detach(&observer1);
	subject.SetStatus("状态2");
	subject.Notify();

	system("pause");

	return 0;
}

输出：