设计模式：14 观察者模式

观察者模式：发布-订阅模式。

定义一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当这个主题对象状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

 

Subject:通知者

Subject:它所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供接口，可以增加和删除观察者对象

Observer:抽象观察者，为所有的具体观察者定义一个接口。在得到主题的通知时更新自己。

ConcreteSubject:具体主题，将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给所有登记过的观察者发出通知

ConcreteObserver:具体观察者，实现抽象观察者角色所要求的更新皆苦，以便使本身的状态与主题的状态相协调。

 

何时使用：当一个对象的改变需要同时改变其他对象时+且不知道具体多少对象等待改变

目的：解除耦合，让耦合的双方依赖于抽象。实际上就是双父类的风格，不要依赖具体，使得各自的变化不会影响另一边的变化。

 

委托：是一种引用方法的类型，一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看作是对函数的抽象，是函数的类，委托的实例将代表具体的函数。

delegate void EventHandler()

一个委托可以搭载多个方法，所有方法被依次唤起。使得委托对象所搭载的方法并不需要属于同一个类。

委托对象所搭载的所有方法必须具有相同的原型和方式，拥有相同的参数列表和返回值类型。

 

main.cpp

#include <iostream>
#include <stdlib.h>
#include <memory>
#include "Observer.h"
#include "Subject.h"
#include "Boss.h"
#include "NBAObserver.h"
#include "StockObserver.h"

using namespace std;

void process()
{
	std::shared_ptr<Subject> machaoPtr(new Boss());
	machaoPtr->_sStatus = "我马超王者归来";
	std::shared_ptr<Observer> ptrStockObserver(new StockObserver("陈浩",machaoPtr));
	std::shared_ptr<Observer> ptrNbaObserver(new NBAObserver("董凯华",machaoPtr));
	//StockObserver stockObserver("陈浩",machao);
	//NBAObserver nbaObserver("董凯华",machao);
	machaoPtr->attach(ptrStockObserver);
	machaoPtr->attach(ptrNbaObserver);
	machaoPtr->notify();
}

int main(int argc,char* argv[])
{
	process();
	system("pause");
	return 0;
}

 

Boss.h

#ifndef BOSS_H
#define BOSS_H
#include "subject.h"
#include <vector>
#include <string>
#include <memory>
class Observer;
class Boss :
	public Subject
{
public:
	Boss(void);
	~Boss(void);
	void attach(std::shared_ptr<Observer> ptrObserver);
	void detach();
	void notify();
private:
	std::vector< std::shared_ptr<Observer> > _vecPtrObservers;
	//可能这边强制转换为Observer导致多态失败，这里可能需要存放智能指针
	std::string _sAction;
};
#endif

 

Boss.cpp

#include "Boss.h"
#include "Observer.h"

Boss::Boss(void)
{
}


Boss::~Boss(void)
{
}

void Boss::attach(std::shared_ptr<Observer> ptrObserver)
{
	 _vecPtrObservers.push_back(ptrObserver);
}

//减少
void Boss::detach()
{
	if(!_vecPtrObservers.empty())
	{
		
	}
}

void Boss::notify()
{
	for(unsigned i = 0 ; i < _vecPtrObservers.size() ; i++)
	{
		_vecPtrObservers.at(i)->show();//为什么没有显示出来，因为没用指针和引用导致多态失败
	}
}

Observer.h

#ifndef OBSERVER_H
#define OBSERVER_H
#include <string>
#include <memory>
#include "Subject.h"
class Subject;
//观察者被主题者通知
class Observer
{
public:
	//Observer(const std::string& sName , Subject& subject);
	Observer(const std::string& sName , std::shared_ptr<Subject> ptrSubject);
	virtual ~Observer(void);
	virtual void show();
protected:
	std::string _sName;
	std::shared_ptr<Subject> _ptrSubject;
};
#endif

Observer.cpp

#include "Observer.h"


//Observer::Observer(const std::string& sName , Subject& subject)
Observer::Observer(const std::string& sName , std::shared_ptr<Subject> ptrSubject)
{
	_sName = sName;
	_ptrSubject = ptrSubject;
	//_ptrSubject.reset(&subject);
}


Observer::~Observer(void)
{
}

void Observer::show()
{
}

NBAObserver.h

#ifndef NBAObSERVER_H
#define NBAOBSERVER_H
#include "observer.h"
class NBAObserver :
	public Observer
{
public:
	NBAObserver(const std::string& sName , std::shared_ptr<Subject> ptrSubject);
	~NBAObserver(void);
	void show();
};
#endif 

NBAObserver.cpp

#include "NBAObserver.h"
#include <iostream>

using namespace std;


NBAObserver::NBAObserver(const std::string& sName , std::shared_ptr<Subject> ptrSubject):Observer(sName , ptrSubject)
{
}


NBAObserver::~NBAObserver(void)
{
}

void NBAObserver::show()
{
	cout << _ptrSubject->_sStatus << "," << _sName << " 关闭NBA直播，继续工作" << endl; 
}

StockObserver.h

#ifndef STOCKOBSERVER_H
#define STOCKOBSERVER_H
#include "observer.h"
class StockObserver :
	public Observer
{
public:
	StockObserver(const std::string& sName , std::shared_ptr<Subject> ptrSubject);
	~StockObserver(void);
	void show();
};
#endif

StockObserver.cpp

#include "StockObserver.h"
#include <iostream>

using namespace std;


StockObserver::StockObserver(const std::string& sName , std::shared_ptr<Subject> ptrSubject):Observer(sName,ptrSubject)
{
}


StockObserver::~StockObserver(void)
{
}

void StockObserver::show()
{
	cout << _ptrSubject->_sStatus << "," << _sName << " 关闭股票行情，继续工作" << endl; 
}

Subject.h

#ifndef SUBJECT_H
#define SUBJECT_H
#include "Observer.h"
class Observer;
#include <string>
class Subject
{
public:
	Subject(void);
	virtual ~Subject(void);
	virtual void attach(std::shared_ptr<Observer> ptrObserver);
	virtual void detach();
	virtual void notify();
public:
	std::string _sStatus;
};
#endif

Subject.cpp

#include "Subject.h"


Subject::Subject(void)
{
}


Subject::~Subject(void)
{
}


void Subject::attach(std::shared_ptr<Observer> ptrObserver)
{

}

void Subject::detach()
{
}

void Subject::notify()
{
}