Head First 设计模式-C++实现---观察者模式

1.意图

观察者模式(Observer Pattern)：定义对象间的一种一对多依赖关系，当一个对象状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

2. 别名

依赖（Dependents），发布-订阅（Publish/Subscribe）模式；

3.动机：

 降低各类紧密耦合；

4.观察者 -》被通知对象；  主题（subject）对象 -》主动通知对象；

  主题对象基类，拥有观察者对象的基类指针的 列表，从主题对象基类派生的 派生主题对象，通过这个列表，注册保存观察者对象的 基类指针；

 观察者基类，有update接口进行更新操作，派生的观察者对象，拥有 主题对象基类，通过主题对象基类，将其本身(this指针）注册（保存）到主题对象中；

 

Head First设计模式上的观察者模式使用java语言实现，这里用C++语言来实现：

Subject.h

#pragma once
#include<memory>
#include<list>
class Observer;
class Subject
{
public:
	virtual void registerObserver(Observer* obs) = 0;
	virtual void deleteObserver(Observer* obs) = 0;
	virtual void notifyObservers() = 0;
	
protected:
	std::list<Observer*> m_observers;
};

DerivedSubject.h

#pragma once
#include "Subject.h"
#include<memory>

class Observer;
class DerivedSubject : public Subject
{
public:
	DerivedSubject();
	~DerivedSubject();

	void registerObserver(Observer* obs)override;
	void deleteObserver(Observer* obs)override;
	void notifyObservers()override;

	float getTemperature();
	float getHumidity();
	float getPressure();
	//当从气象站得到更新观测值时， 通知观察者
	void measurementsChanged();
	void setMesurements(float temperature, float humidity, float pressure);
private:
	float m_temperature;
	float m_humidity;
	float m_pressure;
};

Observer.h

#pragma once
class Observer
{
public:
	virtual void update(float temp, float humidity, float pressure) = 0;
	virtual ~Observer() {};
};

DisplayElement.h

#pragma once
class DisplayElement
{
	virtual void display() = 0;
};

DerivedObserver.h

#pragma once
#include "Observer.h"
#include "DisplayElement.h"
#include<memory>
class Subject;
class DerivedObservers : public Observer, public DisplayElement
{
public:
	DerivedObservers(Subject* weatherData);
	~DerivedObservers();
	void update(float temp, float humidity, float pressure)override;
	void display()override;
private :
	float m_temperature;
	float m_humidity;
	Subject* m_pWeatherData;
};

SecondObserver.h

#pragma once
#include "Observer.h"
#include "DisplayElement.h"
#include<memory>
class Subject;
class secondObserver:public Observer, public DisplayElement
{
public:
	secondObserver(Subject* obj);
	~secondObserver();
	void update(float temp, float humidity, float pressure)override;
	void display()override;
private:
	float m_temperature;
	float m_humidity;
	Subject* m_pWeatherData;
};

 

主题的实现:

DerivedSubject.cpp

#include "pch.h"
#include "DerivedSubject.h"
#include"Observer.h"

DerivedSubject::DerivedSubject()
{
}


DerivedSubject::~DerivedSubject()
{
	if(m_observers.size()>0)
		m_observers.clear();
}

void DerivedSubject::registerObserver(Observer* obs)
{
	m_observers.push_back(obs);
}
void DerivedSubject::deleteObserver(Observer* obs)
{
	m_observers.remove(obs);
}
void DerivedSubject::notifyObservers()
{
	for (auto obs : m_observers)
	{
		obs->update(m_temperature, m_humidity, m_pressure);
	}
}

float DerivedSubject::getTemperature()
{
	return 0;
}
float DerivedSubject::getHumidity()
{
	return 0;
}
float DerivedSubject::getPressure()
{
	return 0;
}
void DerivedSubject::measurementsChanged()
{
	notifyObservers();
}
void DerivedSubject::setMesurements(float temperature, float humidity, float pressure)
{
	this->m_temperature = temperature;
	this->m_humidity = humidity;
	this->m_pressure = pressure;
	measurementsChanged();
}

 

观察者的实现

DerivedObserver.cpp

#include "pch.h"
#include "DerivedObservers.h"
#include "Subject.h"
#include <iostream>

DerivedObservers::~DerivedObservers()
{
	
}
DerivedObservers::DerivedObservers(Subject* weatherData)
{
	this->m_pWeatherData = weatherData;
	m_pWeatherData->registerObserver(this);
}

void DerivedObservers::update(float temp, float humidity, float pressure)
{
	this->m_temperature = temp;
	this->m_humidity = humidity;
	display();
}

void DerivedObservers::display()
{
	std::cout << "Current conditions: " << m_temperature << "F degrees and " << m_humidity << "% humidity" << std::endl;
}

 

SecondObserver.cpp

#include "pch.h"
#include "secondObserver.h"
#include <iostream>
#include"Subject.h"
secondObserver::secondObserver(Subject* weatherData)
{
	this->m_pWeatherData = weatherData;
	m_pWeatherData->registerObserver(this);
}


secondObserver::~secondObserver()
{
}
void secondObserver::update(float temp, float humidity, float pressure)
{
	this->m_temperature = temp;
	this->m_humidity = humidity;
	display();
}

void secondObserver::display()
{
	std::cout << "second conditions: " << m_temperature << "F degrees and " << m_humidity << "% humidity" << std::endl;
}

 

main.cpp

#include "pch.h"
#include <iostream>
#include "DerivedObservers.h"
#include "DerivedSubject.h"
#include"Observer.h"
#include"secondObserver.h"

int main()
{
	DerivedSubject* weatherData =new DerivedSubject;
	Observer* obj = new DerivedObservers(weatherData);
	Observer* sobj = new secondObserver(weatherData);
	weatherData->setMesurements(80, 65, 30.4f);
	weatherData->setMesurements(82, 70, 29.2f);
	weatherData->setMesurements(78, 90, 29.2f);
	std::cout << "------------------delete observer-------------------------" << std::endl;
	weatherData->deleteObserver(obj);
	weatherData->setMesurements(58, 40, 19.2f);
	system("pause");
}

 

输出：