观察者模式实现（模仿CSharpMessenger扩展）

最新推荐文章于 2023-03-06 10:59:58 发布
最新推荐文章于 2023-03-06 10:59:58 发布
阅读量239 收藏
点赞数 1
分类专栏： c/c++ 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaixh_89/article/details/84792704
版权

我们在游戏开发中经常会用到这种模式，用于模块之间的消息分发，来降低模块之间耦合性，基本原来就是利用字符串作为key值来存储回调函数（大多数观察者模式使用字符串作为消息队列中的key值），分发消息时检索key值来获取回调函数并执行来达到模块之间交互的功能，为了实现消息类型拓展，这里我使用了类模板来实现，由于c++编译器对类模板的限制，因此类模板成员函数的实现我也放在了头文件中，代码之中不作说明

头文件：

#include <iostream>
#include <vector>
#include <map>



//消息系统
//无参数
class Message
{
public:	
	typedef void(*CallBack)();
	Message() {}
	~Message() { messageMap.clear(); }
	static Message* instance;
	void Clean();
	static Message* GetInstance();
	void AddListener(std::string eventType, CallBack callback);
	void RemoveListener(std::string eventType, CallBack callback);
	void Dispatch(std::string eventType);
private:
	std::map<std::string, std::vector<CallBack>> messageMap;
};


//单参数
template<class T>
class MessageI
{
public:
	typedef void(*CallBack)(T args);
	MessageI() {}
	static MessageI<T>* GetInstance();
	void AddListener(std::string eventType, CallBack callback);
	void RemoveListener(std::string eventType, CallBack callback);
	void Dispatch(std::string eventType, T arg1);
	void Clean();

private:
	std::map<std::string, std::vector<CallBack> > messageMap;
	static MessageI<T>* instanceI;
};

template<class T>
MessageI<T>* MessageI<T>::instanceI = NULL;

template<class T>
MessageI<T>* MessageI<T>::GetInstance()
{
	if (!instanceI)
	{
		instanceI = new MessageI<T>();
	}
	return instanceI;
}

template<class T>
void MessageI<T>::Clean()
{
	messageMap.clear();
}

template<class T>
void MessageI<T>::AddListener(std::string eventType, CallBack callback)
{
	auto iter = messageMap.find(eventType);
	if (iter != messageMap.end())
	{
		iter->second.push_back(callback);
	}
	else
	{
		vector<CallBack> temp;
		temp.push_back(callback);
		messageMap.insert(make_pair(eventType, temp));
	}
}

template<class T>
void MessageI<T>::RemoveListener(std::string eventType, CallBack callback)
{
	auto iter = messageMap.find(eventType);
	if (iter == messageMap.end())
	{
		cout << "error:删除不存在的消息 name = " << eventType.c_str() << endl;
	}
	else
	{
		auto funcVec = iter->second;
		for (auto iter = funcVec.begin(); iter != funcVec.end(); iter++)
		{
			if (*iter == callback)
			{
				funcVec.erase(iter);
				break;
			}
		}
		if (funcVec.size == 0)
		{
			messageMap.erase(iter);
		}
	}
}

template<class T>
void MessageI<T>::Dispatch(std::string eventType, T arg1)
{
	auto iter = messageMap.find(eventType);
	if (iter == messageMap.end())
	{
		cout << "error:触发不存在的消息 name = " << eventType.c_str() << endl;
	}
	else
	{
		auto funcVec = iter->second;
		for each (auto var in funcVec)
		{
			if (var)
			{
				var(arg1);
			}
			else
			{
				cout << "error:回调函数为null name = " << eventType.c_str() << endl;
			}
		}
	}
}


//两个参数
template<class T, class U>
class MessageII
{
public:
	typedef void(*CallBack)(T args1, U args2);
	MessageII() {}
	static MessageII<T, U>* GetInstance();
	void AddListener(std::string eventType, CallBack callback);
	void RemoveListener(std::string eventType, CallBack callback);
	void Dispatch(std::string eventType, T args1, U args2);
	void Clean();

private:
	std::map<std::string, std::vector<CallBack> > messageMap;
	static MessageII<T, U>* instanceII;
};

template<class T, class U>
MessageII<T, U>* MessageII<T, U>::instanceII = NULL;

template<class T, class U>
MessageII<T, U>* MessageII<T, U>::GetInstance()
{
	if (!instanceII)
	{
		instanceII = new MessageII<T, U>();
	}
	return instanceII;
}

template<class T, class U>
void MessageII<T, U>::Clean()
{
	messageMap.clear();
}

template<class T, class U>
void MessageII<T, U>::AddListener(std::string eventType, CallBack callback)
{
	auto iter = messageMap.find(eventType);
	if (iter != messageMap.end())
	{
		iter->second.push_back(callback);
	}
	else
	{
		vector<CallBack> temp;
		temp.push_back(callback);
		messageMap.insert(make_pair(eventType, temp));
	}
}

template<class T, class U>
void MessageII<T, U>::RemoveListener(std::string eventType, CallBack callback)
{
	auto iter = messageMap.find(eventType);
	if (iter == messageMap.end())
	{
		cout << "error:删除不存在的消息 name = " << eventType.c_str() << endl;
	}
	else
	{
		auto funcVec = iter->second;
		for (auto iter = funcVec.begin(); iter != funcVec.end(); iter++)
		{
			if (*iter == callback)
			{
				funcVec.erase(iter);
				break;
			}
		}
		if (funcVec.size == 0)
		{
			messageMap.erase(iter);
		}
	}
}

template<class T, class U>
void MessageII<T, U>::Dispatch(std::string eventType, T args1, U args2)
{
	auto iter = messageMap.find(eventType);
	if (iter == messageMap.end())
	{
		cout << "error:触发不存在的消息 name = " << eventType.c_str() << endl;
	}
	else
	{
		auto funcVec = iter->second;
		for each (auto var in funcVec)
		{
			if (var)
			{
				var(args1, args2);
			}
			else
			{
				cout << "error:回调函数为null name = " << eventType.c_str() << endl;
			}
		}
	}
}

源文件：

#include "stdafx.h"
#include "Message.h"
using namespace std;


Message* Message::instance = nullptr;
Message* Message::GetInstance()
{
	if (instance == nullptr)
	{
		instance = new Message();
	}
	return instance;
}

void Message::Clean()
{
	messageMap.clear();
}

void Message::AddListener(string eventType, CallBack callback)
{
	auto iter = messageMap.find(eventType);
	if (iter != messageMap.end())
	{
		iter->second.push_back(callback);
	}
	else
	{
		vector<CallBack> temp;
		temp.push_back(callback);
		messageMap.insert(make_pair(eventType, temp));
	}
}

void Message::RemoveListener(string eventType, CallBack callback)
{
	auto iter = messageMap.find(eventType);
	if (iter == messageMap.end())
	{
		cout << "error:删除不存在的消息 name = "<<eventType.c_str()<<endl;
	}
	else
	{
		auto funcVec = iter->second;
		for (auto iter = funcVec.begin(); iter != funcVec.end(); iter++)
		{
			if (*iter == callback)
			{
				funcVec.erase(iter);
				break;
			}
		}
		if (funcVec.size() == 0)
		{
			messageMap.erase(iter);
		}
	}
}

void Message::Dispatch(string eventType)
{
	auto iter = messageMap.find(eventType);
	if (iter == messageMap.end())
	{
		cout << "error:触发不存在的消息 name = " << eventType.c_str() << endl;
	}
	else
	{
		auto funcVec = iter->second;
		for each (auto var in funcVec)
		{
			if (var)
			{
				var();
			}
			else
			{
				cout << "error:回调函数为null name = " << eventType.c_str() << endl;
			}
		}
	}
}

当前实现了无参消息分发、一个参数消息分发、两个参数消息分发，后续有需求可以对照拓展即可

使用例子如下：

// EventTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include "Message.h"
using namespace std;


void pint()
{
	cout << "a" << endl;
}

void pint2()
{
	cout << "b" << endl;
}

void test1(int a)
{
	cout<<"call test1 value = " << a << endl;
}
void test2(int b)
{
	cout << "call test2 value = " << b << endl;
}

void test3(int a, string str)
{
	cout << "a = " << a << ", str = " << str.c_str() << endl;
}

void test4(string str1, string str2)
{
	cout << "str1 = " << str1.c_str() << ", str2 = " << str2.c_str() << endl;
}

int main()
{
	Message::GetInstance()->AddListener("test", pint);
	Message::GetInstance()->AddListener("test", pint2);
	Message::GetInstance()->Dispatch("test");
	
	MessageI<int>::GetInstance()->AddListener("test", test1);
	MessageI<int>::GetInstance()->AddListener("test", test2);
	MessageI<int>::GetInstance()->Dispatch("test", 10);

	MessageII<int, string>::GetInstance()->AddListener("test", test3);
	MessageII<string, string>::GetInstance()->AddListener("test", test4);
	MessageII<int, string>::GetInstance()->Dispatch("test", 15, "HelloWorld");
	MessageII<string, string>::GetInstance()->Dispatch("test", "ko", "HelloWorld");

	system("pause");
	return 0;
}

输出：

 

zhaixh_89
关注
专栏目录
观察者模式的 C语言实现
Raintoo
04-26 552
#include <stdlib.h> #include <stdio.h> #include <assert.h> #include <string.h> #define MAX_OBSERVER (10) #define NAME_SIZE (10) // =================链表数据结构=============== t...
Android开发模式之观察者模式
weixin_43858011的博客
10-25 2815
定义对象一种一对多的依赖关系，使得当一个对象改变状态的时候，所有依赖它的对象都会得到通知并自动更新。观察者模式是一种使用频率非常高的设计模式，最常用的地方就是订阅-发布系统。
观察者模式的扩展--随记
gongkanaa的专栏
01-29 419
背景，最近项目用的是socket通信，socket会不断的更新后台数据，而这时，一个界面得观察好几个数据的变化，而这几个数据都是同类型，导致界面接受的一方，无法区分。 java自带的Observable中的Observer是一个list，这样导致只能把object通知到Observer中去，而不能以何种方式通知过去。还有我用的是socket通信，是在thread中刷数据的，要更新UI必须还得一个ha
设计模式之观察者模式（Observe）-泛型扩展
千里之行，始于足下
10-16 1507
设计模式之观察者模式（Observer） 本篇为 https://github.com/iluwatar/java-design-patterns/tree/master/observer 阅读笔记 扩展部分是很精彩 意图 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 场景 观测天气（机器观测，人工观测），天气变化时，观测者做相...
设计模式-观察者模式-C实现（已亲测）
最新发布
Michael
03-06 278
Subject 接口包括一个观察者列表和三个方法：attach 用于将观察者添加到列表中，detach 用于将观察者从列表中移除，notify 用于通知所有观察者状态发生了改变。在 main 函数中，我们创建了一个被观察者和两个观察者，然后将这两个观察者添加到被观察者的观察者列表中。接着，我们调用了被观察者的 notify 方法，通知所有观察者状态发生了改变，并输出了观察者接收到的数据。最后，我们将一个观察者从列表中移除，再次调用 notify 方法，观察到只有一个观察者接收到了数据。
设计模式的C语言应用-观察者模式-第四章
华为云官方博客
07-15 2015
模式介绍：观察者模式(Observer) 观察者模式定义了对象之间的一对多依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且自动更新。在这里，发生改变的对象称之为观察目标，而被通知的对象称之为观察者。一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，所以么可以根据需要增加和删除观察者，使得系统更易于扩展。 图表1观察者模式流程图 观察者模式在C语言里...
接口实现C#观察者模式简单例子
07-27
在本示例中，我们将探讨如何使用接口来实现C#中的观察者模式。 首先，我们定义一个主题（Subject），它维护一个观察者列表，并提供添加、删除观察者以及通知所有观察者的方法。在C#中，我们可以创建一个名为`...
java 观察者模式类图_设计模式——观察者模式
weixin_33788424的博客
02-25 2821
生活中，许多事物不是单独存在的，其中一个事物发生变化可能会导致一个或多个其他事物的行为也发生变化。例如：公众号的博主与用户之间(每当推送一篇文章，我们就能被动的接收到一篇文章，前提是你关注了它)。在软件设计中也是一样，例如：MVC 模式中的模型与视图的关系。此类场景使用观察者模式来实现的话，就非常方便。一、观察者模块的定义与优缺点观察者模式(Observer Pattern)：定义对象间的一种一对...
设计模式（五）观察者模式
热门推荐
Android进阶三部曲 - 刘望舒
03-02 13万+
观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听莫一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。
设计模式——观察者模式
白日梦
01-05 2316
前言：观察者模式是23种设计模式中较为常用的一种设计模式。 观察者模式 1.观察者模式定义 观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。 2.观察者模式的特点： 特点: 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。 目标与观察者之间建立了一套触发机制。 注意事项： 实现观察者模式时要注意具体目标对象和具体观
Messenger客户端
08-18
「探索」如何運作： 當用戶按下位於Messenger主頁右下角的「探索」圖示後，能依據類別尋找近期瀏覽過的商家商品及特色體驗。「探索」讓用戶更輕易地在Messenger上閱讀新文章、預訂下個旅行目地或是獲得最新的體育焦點。Facebook將同步更新「探索」功能裡出現的各項指標，提供用戶更多曾關注過的企業相關訊息，讓用戶從中找出理想的資訊。 Facebook Messenger 将提供聊天翻译功能 2018年5月，在举行的F8开发者大会上，Facebook宣布将通过智能助手M，在Messenger应用内提供聊天翻译功能。Facebook Messenger将新增自动翻译功能，以便于卖家和买家在买卖中能够进行沟通交流 当用户尝试在Facebook Marketplace上尝试交易的时候，如果收到非当前软件所设置的语言内容，那么Messenger的M聊天机器人就会自动将其翻译。
C语言实现设计模式—观察者模式
Clear Code
08-26 3201
文章目录C语言实现设计模式—观察者模式观察者模式介绍UML用例说明C语言实现定义触发更新函数接口采集线程等待触发标志更新波形存储标志等待更新 C语言实现设计模式—观察者模式 观察者模式介绍 它就像系统里面某个子模块的跑腿，一旦该子模块发生变化，它就要为这个子模块通知其他的子模块。 观察者模式定义: 定义对象之间多对一的依赖关系，保证当被依赖的对象发生变化时，所有的依赖者会被自动更新。 当一个对象需要通知另外一些对象，而你无法预知哪些对象将被通知时，通过观察者模式，克制减少对象的偶合关系。 优点： 1、观
c语言观察者模式,C语言的观察者模式
weixin_42542420的博客
05-19 87
/*hdr** Copyright ...** AUTHOR MichaelMa** DATE 4-May-2014** DESCRIPTION implement a mode of observer in C** NOTE may be some bugs*/#include #in...
21. 23种经典设计模式-34-观察者模式扩展
Java 程序源
08-27 268
1. 观察者模式扩展 笔者上篇博客中提到, 对于四人帮定义的标准观察者模式而言, 有两个问题: 观察者中需要持有具体观察者的引用，这样导致观察者与被观察者直接有强耦合关系 观察者更新方法需要调用被观察者的方法获取实时状态, 虽然这种是为了保证消息通知时最小量化消息的设计，但是在多线程时，我们可能那不到实际触发变更时的状态。因此我们可以此进行改进，观察者的更新方法接收一个参数，接收变化的内容. ...
设计模式之观察者模式（C语言）
Hongggggggg
01-09 513
介绍： 观察者模式是一种行为设计模式， 允许你定义一种订阅机制， 可在对象事件发生时通知多个 “观察” 该对象的其他对象。 问题： ​ 假如顾客对某个特定的产品非常感兴趣 ， 而该产品很快将会在商店里出售。顾客可以每天来商店看看产品是否到货。但如果商品尚未到货时，顾客就会空手而归。另一方面，每次新产品到货时，商店可以向顾客发送邮件。这样，顾客就无需反复前往商店了，但这样同时也可能会惹恼对新产品没有兴趣的其他顾客。 ​ 所以我们似乎遇到了一个矛盾：要么让顾客浪费时间检查产品是否到货， 要么让商店浪费资源去通
c语言设计模式代码完整实现-观察者模式(Observer)
jenie的专栏
06-02 2678
模式介绍：观察者模式(Observer) 观察者模式定义了对象之间的一对多依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且自动更新。在这里，发生改变的对象称之为观察目标，而被通知的对象称之为观察者。一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，所以么可以根据需要增加和删除观察者，使得系统更易于扩展。 图表1观察者模式流程图 观察者模式在C语言里也是实现形式非常明显的模式。逻辑上和责任链模式最相近的一个设计模式为观察者模式...
观察者模式 (Java内置观察者模式以及扩展)
jj89929665的博客
03-30 329
观察者模式什么是观察者模式优点：缺点：公众号 实例UML图Observable 被观察者WeatherData 具体被观察者Observer 观察者接口DisplayElement接口 对观察者的行为进行扩展GeneralDisplay 具体观察者测试类随之而来的问题如何解决？如何扩展 `加一层`（这是我的想法，不对可以指出） 什么是观察者模式 当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。
C语言和设计模式（观察者模式）
qq_23929673的博客
01-26 383
文章目录一句话理解举例 一句话理解 抽象出众多对象共同的属性，该属性变化后，其他属性全部跟着改变，而不需要针对每个对象依次修改 举例  观察者模式可能是我们在软件开发中使用得比较多的一种设计模式。为什么这么说？大家可以听我一一到来。我们知道，在windows的软件中，所有的界都是由窗口构成的。对话框是窗口，菜单是窗口，工具栏也是窗口。那么这些窗口，在很多情况下要对一些共有的信息进行处理。比如说，窗...
C常用设计模式——观察者模式
u012166632的专栏
09-25 1038
文章首发于知乎专栏： https://zhuanlan.zhihu.com/c_1136684995157577728 个人公众号TarysThink 观察者（Observer）模式，观察者是什么人，是一个冷眼观瞧的人，这个人距离事件的中心很远，也就是说观察者与信息发布者之间能够解耦，这应该是观察者模式的核心。 有这么个场景，A是一个模块，A模块内有一个数据a，这个数据a是需要模块B...
Java8实现观察者模式详解
"本文将介绍如何使用Java8实现观察者模式，探讨该模式的基本概念、在Java中的应用以及解决在实现过程中可能遇到的问题。" 观察者模式是一种设计模式，允许一个对象（称为主题或被观察者）在状态发生变化时通知其他...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值