【学习笔记】C/C++ 设计模式 - 观察者模式

最新推荐文章于 2022-01-14 11:46:44 发布
最新推荐文章于 2022-01-14 11:46:44 发布
阅读量217 收藏 1
点赞数
分类专栏： Linux 应用开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovemengx/article/details/104077775
版权

前言

        估计 2020 年写应用程序的机会比较多，之前一直在做嵌入式驱动程序和Android系统定制方面的工作，在应用程序方面积累的不是很多，因此迫切需要多学学应用编程这方面的知识。

       之前在写小的应用程序的时候，总感觉会有更好的实现方式解耦，当时只是觉得要解决我所面临的瓶颈，可能需要找几个比较优秀的开源代码，多学习学习。因为一个偶然的机会接触设计模式之后，我嘞个去，这不就是可以解决困扰我很长时间的解耦问题的最佳解决方案吗？哈哈，在此写下自己的学习心得便于日后复习使用。

      引用百度百科：软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

观察者模式

简单介绍

       观察者模式非常像我之前接触的 MQTT 协议中的发布/订阅机制，以及和 Android 中的广播机制。它们都是对某种消息\事件感兴趣就注册监听该消息\事件变化的场景。

       借助该设计模式可以实现：产生事件的专注于事件检测逻辑，处理事件的专注于事件处理逻辑，不同的事件检测由不同的逻辑实现，不同的事件处理也由不同的事件处理逻辑实现，他们之间借助观察者模式即可实现联动。

       因此可以将产生事件和处理事件的代码进行解耦隔离，各自处理互不干扰，这样实现的代码更加清晰明了和易于维护与扩展。如果我们在工作当中遇到类似的场景即可应用该设计模式。

应用场景

       例：多对多，互联网领域，一个微博里面的某个明星即可认为是被观察者，关注该微博的粉色即可认为是观察者，当明星发布一条动态，那么所有关注其的粉丝都会收到该动态。多对多的场景，粉丝也可以同时关注其它的明星动态。（当然实际情况会更加复杂些，因为粉色自己也可以作为被观察者被人关注动态，这里只是举例说明，便于理解）

       例：一对多，智能家居领域，需要实现离家安防模式，短信告警逻辑，视频录音录像逻辑，现场声光告警逻辑均可作为观察者，如借助人体红外感应实现的非法入侵检测逻辑功能，作为被观察者。当被观察者触发事件后（检测到非法入侵），那么就会触发短信告警、启动视频录音录像、启动现场喇叭和警示灯等功能逻辑。

原理说明

      观察者设计模式是通过 C++ 面向对象的机制实现，主要是借助了继承的特性（继承权限、子类转换父类、纯虚函数），以及辅助用的模板类 list 实现。设计思想是首先编写两个类作为框架：

      一个是被观察者类：

  1.  主要是维护一个观察者列表，用于记录有哪些观察者需要通知，该列表是 private 的，仅限于被观察者类框架自己维护。
  2.  提供增加和移除观察者的接口，用于登记和删除观察者，该接口是 public 的，所有对象都可以调用。
  3.  提供通知事件接口，用于通过遍历观察者列表，依次逐个调用观察者的事件回调来实现通知各个观察者，该接口是protected的，仅限于并且只应由派生类（即某个具体的被观察者）在产生事件时调用（这里决定了观察者回调函数不可阻塞和执行太复杂的代码，否则会影响后续的观察者事件通知不及时，也会影响被观察者的通知事件接口的执行事件时间长短）。
  4. 这里的回调主要是通过将继承了观察者的对象转换为其父类即观察者之后，再调用观察者的事件回调函数实现。

      一个是观察者类：

  1.  提供一个事件回调纯虚函数，由某个具体的观察者继承实现，将会由被观察者产生事件的时候调用，由此得到通知。
  2.  可以增加一些额外的数据结构，如事件类型等等。

     被观察者的具体实现

  1.  某个对象继承被观察者类。
  2.  产生某些事件时，其父类的通知事件接口，传入相应的参数即可。

      观察者的具体实现

  1.  启动一个线程，利用队列和条件变量来让线程等待事件 。
  2.  某个对象继承观察者者类，并实现父类的事件回调的纯虚函数。
  3.  当事件触发时，将事件写入队列，并通过条件变量唤醒线程做业务处理。

示例代码

被观察者类框架

/**
******************************************************************************
* @文件		Subject.h
* @版本		V1.0.0
* @日期
* @概要		被观察者框架实现
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

#ifndef __SUBJECT_H
#define __SUBJECT_H

#include <iostream>
#include <list> 
#include <mutex>
#include "ObServer.h"

using namespace std;

// 被观察者(谁需要发布主题, 则继承并且在合适的时候调用通知方法)
class Subject
{
private:   // 私有的, 由框架自己维护的数据结构, 主要用于维护观察者列表
    mutex               list_mutex;
    list <ObServer*>   observer_list;

protected: // 保护的, 由派生类使用的接口, 借此发布通知(仅对派生类可见, 但不公开, 避免被其它地方通过派生类使用)
    int notice(ObServer::OBSERVER_EVENT_TYPE_E type, int argc);

public:    // 公有的, 用于将观察者加入或移除观察列表的接口
    int attach(ObServer* observer);
    int detach(ObServer* observer);
};
 
#endif


/**
******************************************************************************
* @文件		Subject.cpp
* @版本		V1.0.0
* @日期
* @概要		被观察者的框架实现
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

#include "Subject.h"

// 通知观察者
int Subject::notice(ObServer::OBSERVER_EVENT_TYPE_E type, int argc)
{
	// 便利所有观察者对象, 并调用其 onEvent 方法来进行通知
	// 如果某个观察者对象中的 onEvent 实现的代码出现阻塞或执行时间过长, 将会影响此循环执行时间
	// 一种解决方式是为每个观察者事件回调函数创建一个线程来执行
	// 另一种解决方式是要求具体的观察者对象各自维护一个事件队列和一个处理事件的线程, 在 onEvent 中将事件存入队列并唤醒处理该事件的线程
	list_mutex.lock();
	for (list<ObServer*>::iterator iter = observer_list.begin(); iter != observer_list.end(); ++iter)
	{
		(*iter)->onEvent(type, argc);	
	}
	list_mutex.unlock();

	return 0;
}

// 将指定的观察者附加到列表中
int Subject::attach(ObServer* observer)
{
	if (NULL == observer)
		return -1;

	list_mutex.lock();
	observer_list.push_back(observer);
	list_mutex.unlock();

	return 0;
}

// 将指定的观察者从列表中分离
int Subject::detach(ObServer* observer)
{
	if (NULL == observer)
		return -1;

	list_mutex.lock();
	observer_list.remove(observer);
	list_mutex.unlock();

	return 0;
}

观察者类框架

/**
******************************************************************************
* @文件		ObServer.h
* @版本		V1.0.0
* @日期
* @概要		观察者框架实现
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

#ifndef __OBSERVER_H
#define __OBSERVER_H

// 观察者-谁需要观察则继承该类
class ObServer
{
public:

	// 观察的事件类型
	typedef enum {
		OBSERVER_EVENT_TYPE_A,			
		OBSERVER_EVENT_TYPE_B,		
	}OBSERVER_EVENT_TYPE_E;

public:

	// 当有事件变动时, 会由被观察者调用, 从而让观察者得到事件通知
	virtual void onEvent(OBSERVER_EVENT_TYPE_E type, int argc) = 0;
};


#endif // !__SUBSCRIBE_H

具体的被观察者

/**
******************************************************************************
* @文件		SubjectTheme.h
* @版本		V1.0.0
* @日期
* @概要		被观察者的具体实现
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

#ifndef __SUBJECT_THEME_H
#define __SUBJECT_THEME_H

#include "../Subject.h"

using namespace std;

// 某具体的被观察者
class SubjectTheme : public Subject
{

private:    
    
    // 利用线程模拟事件产生
    bool        mThreadTimerExitFlags;
    thread      mThreadTimer;
    static void ThreadTimer(SubjectTheme* pSubjectTheme);

public:

    void start();
    void stop();

};
 
#endif


/**
******************************************************************************
* @文件		SubjectTheme.cpp
* @版本		V1.0.0
* @日期
* @概要		被观察者的具体实现
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

#include <windows.h>
#include "SubjectTheme.h"

// 利用线程实现简单的定时产生事件的机制
void SubjectTheme::ThreadTimer(SubjectTheme* pSubjectTheme)
{
	unsigned int count = 0;

	// 间隔一定的时间出发一次事件通知
	while (!pSubjectTheme->mThreadTimerExitFlags)
	{
		count++;
		printf("SubjectTheme: notice...\n");
		pSubjectTheme->notice(ObServer::OBSERVER_EVENT_TYPE_A, count);
		Sleep(1000);
	}

	return;
}

// 启动模拟
void SubjectTheme::start()
{
	printf("SubjectTheme: start...\n");
	mThreadTimerExitFlags = false;
	mThreadTimer = thread(ThreadTimer, this);
	return;
}

// 停止模拟
void SubjectTheme::stop()
{
	printf("SubjectTheme: stop...\n");
	mThreadTimerExitFlags = true;
	mThreadTimer.join();
	return;
}

具体的观察者1

/**
******************************************************************************
* @文件		ObServerSubscribeA.h
* @版本		V1.0.0
* @日期
* @概要		某具体对象作为观察者的示例
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

#ifndef __OBSERVER_SUBSCRIBEA_H
#define __OBSERVER_SUBSCRIBEA_H

#include "../ObServer.h"

class ObServerSubscribeA: public ObServer
{

private:

	// 通过 Observer 继承
	virtual void onEvent(OBSERVER_EVENT_TYPE_E type, int argc) override;


};


#endif 


/**
******************************************************************************
* @文件		ObServerSubscribeA.h
* @版本		V1.0.0
* @日期
* @概要		某具体对象作为观察者的示例
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

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

// 通过 Observer 继承
void ObServerSubscribeA::onEvent(OBSERVER_EVENT_TYPE_E type, int argc)
{
	printf("ObServerSubscribeA: onEvent  type:%d  argc:%d\n", type, argc);
}

具体的观察者2

/**
******************************************************************************
* @文件		ObServerSubscribeB.h
* @版本		V1.0.0
* @日期
* @概要		某具体对象作为观察者的示例
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

#ifndef __OBSERVER_SUBSCRIBEB_H
#define __OBSERVER_SUBSCRIBEB_H

#include "../ObServer.h"

class ObServerSubscribeB : public ObServer
{

private:

	// 通过 Observer 继承
	virtual void onEvent(OBSERVER_EVENT_TYPE_E type, int argc) override;


};


#endif 


/**
******************************************************************************
* @文件		ObServerSubscribeB.h
* @版本		V1.0.0
* @日期
* @概要		某具体对象作为观察者的示例
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

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

// 通过 Observer 继承
void ObServerSubscribeB::onEvent(OBSERVER_EVENT_TYPE_E type, int argc)
{
	printf("ObServerSubscribeB: onEvent  type:%d  argc:%d\n", type, argc);
}

单元测试代码

/**
******************************************************************************
* @文件		test_ObServer.h
* @版本		V1.0.0
* @日期
* @概要		观察者设计模式单元测试
* @作者		lmx
* @邮箱		lovemengx@qq.com
* @博客		https://me.csdn.net/lovemengx
******************************************************************************
**/

#include <iostream>
#include <windows.h>

#include "test_ObServer.h"
#include "Theme/SubjectTheme.h"
#include "Subscribe/ObServerSubscribeA.h"
#include "Subscribe/ObServerSubscribeB.h"

void TestObServer::test(void)
{
	SubjectTheme		mSubjectTheme;
	ObServerSubscribeA	mObServerSubscribeA;
	ObServerSubscribeB	mObServerSubscribeB;

	mSubjectTheme.attach(&mObServerSubscribeA);
	mSubjectTheme.attach(&mObServerSubscribeB);

	mSubjectTheme.start();
	Sleep(10 * 1000);
	mSubjectTheme.stop();

	return;
}

执行结果

lovemengx
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++观察者模式
萧海的博客
10-28 159
头文件： #ifndef COBSERVERMODE_H #define COBSERVERMODE_H #include<QDebug> #include <iostream> #include<string> #include <vector> using namespace std; #define cout qDebug() << "[" << __FILE__ << ":" << __LINE__
《C++20设计模式》学习笔记-第12章代理模式-配套代码
最新发布
02-22
《C++20设计模式》学习笔记-第12章代理模式-配套代码
C++ 观察者模式
CodeHouse的博客
11-10 409
#include <iostream> #include <list> using namespace std; //观察者抽象类 class Observer { public: Observer(){;} virtual void doSometing(void* parg)=0; }; class User1:public Observer { public: virtual void doSometing(void* parg) { cout<<
c++观察者模式
c++
01-14 112
观察者模式 1、观察者模式简介   观察者模式也叫发布-订阅模式、模型-视图模式、源-监听器模式以及从属者模式，观察者模式定义了对象之间的一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。 2、实例讲解   假如张三、李四、王五三人都订阅了环球日报的报纸。那么当环球日报的报纸有更新的时候就会送到他们三人手中。 //报纸接口类 class NewsPaperBase { public: //添加订阅者 virtual void RegisterSubscri
c++之观察者模式
c_shell_python的博客
07-14 282
观察者模式属于行为型模式，即当对象间存在一对多关系时，则考虑使用观察者模式。比如，当一个对象被修改时，则会自动通知依赖它的对象。 栗子场景：课堂上，李老师（具体通知者）叫小明（具体观察者）和大红（具体观察者）坐下，然后再单独叫小明站起来。 代码： #include <iostream> #include <list> using namespace std; //抽象观察者 class Observer{ public: virtual void update(std:
观察者模式
jadeshu的博客
01-21 238
  C++代码： #include &lt;string&gt; #include &lt;iostream&gt; #include &lt;list&gt; using namespace std; // 观察者模式 // 观察者 class Observer { public: virtual void Update(int value) = 0; }; // 目标者 clas...
《C++20设计模式》学习笔记-第5章单例模式
02-05
《C++20设计模式》学习笔记-第5章单例模式
《C++20设计模式》学习笔记-第8章组合模式-配套学习代码
02-20
《C++20设计模式》学习笔记-第8章组合模式-配套学习代码
C++20设计模式学习笔记-第7章桥接模式学习代码
02-06
C++20设计模式学习笔记-第7章桥接模式学习代码
《C++20设计模式》学习笔记-第1章引论学习代码
02-04
《C++20设计模式》学习笔记-第1章引论学习代码
c语言设计模式-观察者模式
haozhuo1987999的博客
07-08 223
https://blog.csdn.net/qq153471503/article/details/79183527
C++设计模式——观察者模式
Map的博客
04-10 2162
1.观察者模式 定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动刷新。 观察者模式又叫做发布-订阅(Publish-Subscribe)模式、模型-视图(Model-View)模式、源-监听器(Source-Listener)模式。 2. 场景举例 角色： 抽象主题（Subject）：该角色是一个抽象类或接口，定义了增加、删除、通知观...
c++设计模式——观察者模式
puxin
03-17 160
#pragma once class IObserver { public: virtual ~IObserver() {} virtual void Update(float tmp, float humidity, float pressure) = 0; }; #pragma once #include "IObserver.h" class Observer : pub...
C/C++设计模式(十七) 观察者模式
码之有道
09-08 200
概念 观察者模式（Observer模式）是行为模式之一，它的作用是当一个对象的状态发生变化时，能够自动通知其他关联对象，自动刷新对象状态。 Observer模式提供给关联对象一种同步通信的手段，使某个对象与依赖它的其他对象之间保持状态同步。 角色和职责 Subject（被观察者） 被观察的对象。当需要被观察的状态发生变化时，需要通知队列中所有观察者对象。Subject需要维持（添加，删除，通知）一个观察者对象的队列列表。 ConcreteSubject 被观察者的具体实现。包含一些基本的属性
观察者模式-c++
图图
12-11 1093
00基础：抽象 封装 多态 继承  00原则：封装变化       多用组合， 少用继承               针对接口编程， 不针对实现编程               为交互对象之间的松耦合设计而努力 观察者模式：在对象之间定义一对多的依赖，这样依赖， 当一个对象改变状态，依赖它的对象都会收到通知，并自动更新。 UML类图：
20、C语言和设计模式（观察者模式）
我有我的天空
08-07 843
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     观察者模式可能是我们在软件开发中使用得比较多的一种设计模式。为什么这么说？大家可以听我一一到来。我们知道，在windows的软件中，所有的界都是由窗口构成的。对话框是窗口，菜单是窗口，工具栏也是窗口。那么这些窗口，在很多情况下要对一些共有的信息进行处理。比如说，窗口的放大，窗口的
Libevent的事件驱动源码分析(三)之反应堆的设计
永远积极向上、永远热泪盈眶、永远豪情满怀、永远坦坦荡荡
07-06 560
前言 网络编程使用基本都是反应堆(reactor) 著名C++标准的Boost中asio使用reactor模式， 它的io线程是安全的， libevent使用io也使用该模式 正文 一, reactor模式 1, 采用基于事件驱动的设计，当有事件触发时，才会调用处理器进行数据处理。 Reactor：负责响应IO事件，当检测到一个新的事件，将其发送给相应的Handler去处理。 Handler...
【C++设计模式】观察者模式
qq_43288972的博客
01-24 89
观察者模式 定义 定义对象间的⼀种⼀对多（变化）的依赖关系，以便当⼀个对象(Subject)的状态发⽣改变时，所有 依赖于它的对象都得到通知并⾃动更新。 ——《 设计模式》 GoF 应用场景 侦听事件驱动程序设计中的外部事件 侦听/监视某个对象的状态变化 发布者/订阅者(publisher/subscriber)模型中，当一个外部事件（新的产品，消息的出现等等）被触发时，通知邮件列表中的订阅者 案例 背景 ⽓象站发布⽓象资料给数据中⼼，数据中⼼经过处理，将⽓象信息更新到两个不同的显示终端（A
LTE Initial Attach 的过程以及相关消息的具体解析 （三）
君子梁的专栏
12-14 8716
这段开始描述 MME, SGW, PGW 之间建立Tunnel 的过程。主要使用Create Session Req/Resp for default Bearer 和 Create Bearer Request/Resp for dedicated Bearer setup. so, 1st one is MME send to SGW the Create Session Req,
Not Found: /user/static/plugins/bootstrap-3.4.1-dist/css/bootstrap.css
07-28
- *1* *3* [下载bootstrap并应用（学习笔记4）](https://blog.csdn.net/qyqyqyi/article/details/128754090)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值