Observer 观察者模式_observe subject-优快云博客

本文介绍了一种基于Boost库实现的观察者模式应用案例。通过定义抽象的观察者和被观察者角色，实现了不同主题的数据更新通知机制。具体包括两个主题类（ConcreteSubject1和ConcreteSubject2），以及两个观察者类（ObserverA和ObserverB）。每个主题负责维护观察者列表，并在状态改变时通知所有观察者。观察者则根据主题类型的不同进行相应的更新。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include "stdafx.h"
#include <iostream>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <string>
#include <list>
#include <boost/foreach.hpp>
#include <boost/enable_shared_from_this.hpp>

using namespace boost;

//使用类的继承,抽象类可以实现多态和提高内聚性

//主角1数据
typedef struct _Subject1Data
{
	int iId;
	std::string strName;
}Subject1Data;
//主角2数据
typedef struct _Subject2Data
{
	double dbData;
	std::string strName;
}Subject2Data;

class Subject;
//观察者基类
class Observer
{
public:
	virtual void updateForSubject1(shared_ptr<Subject>) = 0;
	virtual void updateForSubject2(shared_ptr<Subject>) = 0;
	virtual void observeSubject(shared_ptr<Subject> subject) = 0;
public:
	Observer(){}
	virtual ~Observer(){}
};

//主角抽象类
class Subject
{
public:
	virtual void addObserver(shared_ptr<Observer> observer) = 0;
	virtual void removeObserver(shared_ptr<Observer> observer) = 0;
	virtual void Notify() = 0;
	virtual void printData() = 0;

//如果这里设置为protected会编译失败，
//因为用了智能指针，需要设置为protected
//可以用普通指针代替智能指针就可以了
public:
// 	Subject(){}
// 	virtual ~Subject(){}
};

//具体主角类1
class ConcreteSubject1 : public Subject,public enable_shared_from_this<ConcreteSubject1>
{
private:
	std::list<shared_ptr<Observer>> __m_listObservers;

	shared_ptr<ConcreteSubject1> get_shared_ptr_from_this()
	{
		return shared_from_this();
	}
public:
	virtual void addObserver(shared_ptr<Observer> observer)
	{
		__m_listObservers.push_back(observer);
	}
	virtual void removeObserver(shared_ptr<Observer> observer)
	{
		__m_listObservers.remove(observer);
	}
	virtual void Notify()
	{
		BOOST_FOREACH(auto var,__m_listObservers)
		{
			var->updateForSubject1(get_shared_ptr_from_this());
		}
	}

	void setData(int id,const std::string & strName)
	{
		__m_data.iId = id;
		__m_data.strName = strName;
	}

	const Subject1Data& getData()
	{
		return __m_data;
	}
	void printData()
	{
		std::cout << "Subject1 Data:" << __m_data.iId << "," << __m_data.strName << std::endl;
	}
private:
	Subject1Data __m_data; 
};

//具体主角类2
class ConcreteSubject2 : public Subject,public enable_shared_from_this<ConcreteSubject2>
{
private:
	std::list<shared_ptr<Observer>> __m_listObservers;
public:
	virtual void addObserver(shared_ptr<Observer> observer)
	{
		__m_listObservers.push_back(observer);
	}
	virtual void removeObserver(shared_ptr<Observer> observer)
	{
		__m_listObservers.remove(observer);
	}
	virtual void Notify()
	{
		BOOST_FOREACH(auto var,__m_listObservers)
		{
			var->updateForSubject2(get_shared_ptr_from_this());
		}
	}

	void setData(double dbData,const std::string & strName)
	{
		__m_data.dbData = dbData;
		__m_data.strName = strName;
	}
	const Subject2Data& getData()
	{
		return __m_data;
	}
	void printData()
	{
		std::cout << "Subject2 Data:" << __m_data.dbData << "," << __m_data.strName << std::endl;
	}
private:
	Subject2Data __m_data; 

	shared_ptr<ConcreteSubject2> get_shared_ptr_from_this()
	{
		return shared_from_this();
	}
};

//具体观察者A			//多重继承不要忘了加2个public
class ObserverA : public Observer, public enable_shared_from_this<ObserverA>
{
public:
	virtual void updateForSubject1(shared_ptr<Subject> subject1)
	{
		std::cout << "ObserverA update:";
		subject1->printData();
	} 
	virtual void updateForSubject2(shared_ptr<Subject> subject2)
	{
		std::cout << "ObserverA update:";
		subject2->printData();
	}
	virtual void observeSubject(shared_ptr<Subject> subject)
	{
		subject->addObserver(get_shared_ptr_from_this());
	}
private:
	shared_ptr<ObserverA> get_shared_ptr_from_this()
	{
		return shared_from_this();
	}
};

//具体观察者B			//多重继承不要忘了加2个public
class ObserverB : public Observer, public enable_shared_from_this<ObserverB>
{
public:
	virtual void updateForSubject1(shared_ptr<Subject> subject1)
	{
		std::cout << "ObserverB update:";
		subject1->printData();
	} 
	virtual void updateForSubject2(shared_ptr<Subject> subject2)
	{
		std::cout << "ObserverB update:";
		subject2->printData();
	}
	virtual void observeSubject(shared_ptr<Subject> subject)
	{
		subject->addObserver(get_shared_ptr_from_this());
	}
private:
	shared_ptr<ObserverB> get_shared_ptr_from_this()
	{
		return shared_from_this();
	}
};

void testObserverMode()
{
	shared_ptr<ConcreteSubject1> sub1 = make_shared<ConcreteSubject1>();
	shared_ptr<ConcreteSubject2> sub2 = make_shared<ConcreteSubject2>();
	auto obs1 = make_shared<ObserverA>();
	auto obs2 = make_shared<ObserverB>();
	obs1->observeSubject(sub1);
	obs2->observeSubject(sub1);
	obs1->observeSubject(sub2);
	sub1->setData(111,"sub1111");
	sub2->setData(123.222,"sub22222");
	sub1->Notify();
	sub2->Notify();
}