2. 程式人生 > >觀察者模式實現（模仿CSharpMessenger擴充套件）

觀察者模式實現（模仿CSharpMessenger擴充套件）

阿新 • • 發佈：2018-12-11

我們在遊戲開發中經常會用到這種模式，用於模組之間的訊息分發，來降低模組之間耦合性，基本原來就是利用字串作為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;
}

輸出：

 

相關推薦

觀察者模式實現（模仿CSharpMessenger擴充套件）

我們在遊戲開發中經常會用到這種模式，用於模組之間的訊息分發，來降低模組之間耦合性，基本原來就是利用字串作為key值來儲存回撥函式（大多數觀察者模式使用字串作為訊息佇列中的key值），分發訊息時檢索key值來獲取回撥函式並執行來達到模組之間互動的功能，為了實現訊息型別拓展，這裡我使用了類模板來實現

設計模式 ( 十五 ) 觀察者模式Observer（物件行為型）

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

設計模式 ( 十六 ) 觀察者模式Observer（物件行為型）

1.概述 一些面向物件的程式設計方式，提供了一種構建物件間複雜網路互連的能力。當物件們連線在一起時，它們就可以相互提供服務和資訊。 通常來說，當某個物件的狀態發生改變時，你仍然需要物件之間能互相通訊。但是出於各種原因，你也許並不願意因為程式碼環境的改變而對程式碼做大

觀察者模式（基於CSharpMessenger擴充套件）

在使用c#中的事件時，經同事推薦看到了這個框架，它是c#訊息傳遞的高階版本，程式碼不多，拜讀之後對程式碼結構進行了重構，感覺更清晰點 /* * Advanced C# messenger by Ilya Suzdalnitski. V1.0 * * Based on Rod Hyde

如何使用 Java8 實現觀察者模式？（下）

【編者按】本文作者是 BAE 系統公司的軟體工程師 Justin Albano。在本篇文章中，作者通過在 Java8 環境下實現觀察者模式的例項，進一步介紹了什麼是觀察者模式、專業化及其命名規則，供大家參考學習。本文系國內 ITOM 管理平臺 OneAPM 工程

java和c++觀察者模式實現

觀察者模式是一種比較常用的設計模式，，採用介面，封裝類中動態變化的方法，定義物件間的依賴關係，一邊但一個物件狀態發生改變時，所有以來他的物件都發生改變。 簡單的說，就是一管多，即關鍵就是觀察者和被觀察者，學習這一部分看其他部落格這樣解釋，就是多個屌絲追一個白富美的模式，多個屌絲就是所謂的觀察

觀察者模式實現的 `釋出/訂閱` 模型

釋出者 package indi.lewis.pub; import java.util.Observable; import java.util.Observer; import java.uti

設計模式(二)：自己動手使用“觀察者模式”實現通知機制

在之前釋出Objective-C系列部落格的時候，其中提到過OC的通知機制，請參考《Objective-C中的老闆是這樣發通知的（Notification)》這篇部落格。在之前關於Notification的部落格中，只介紹了Foundation框架中的通知的使用方式。正如前面部落格中提到的那樣，通知是“一對多

使用觀察者模式實現執行緒將計算結果回撥給多個物件

《Java網路程式設計》第三章執行緒講使用回撥的方法從執行緒中返回資訊給物件。例如，如果有多個物件對執行緒的計算結果感興趣，那麼執行緒可以儲存一個要回調的物件列表。特定的物件可以通過呼叫執行緒類的一個方法把自己新增到這個列表中來完成註冊，表示自己對計算結果很感興趣。如果有多

觀察者模式實現案例(C++)

#include <iostream> #include <string> #include <vector> #include <memory> using namespace std; class Cat; //前置

es6觀察者模式實現

//es6實現 藉助set實現 function obfunction(oldval,newval){ console.log(oldval+'變成了'+newval); } class targetObser{ constructor(age,name){ this

利用觀察者模式實現Cocos2DX-lua遊戲中的訊息管理系統

http://blog.csdn.net/operhero1990/article/details/48575487                遊戲中某些物件往往需要及時獲知其他特定物件狀體的改變。為降低類之間的耦合度，可以建立訊息管理系統，實現訊息的集中與分發。觀察者

觀察者模式實現老闆狀態變化通知 C++

說下對觀察者模式的理解： 觀察者模式定義了一種一對多的依賴關係， 讓多個觀察者物件可以同時監聽某一主題物件， 當這個主題物件的狀態發生改變的時候， 就會通知所有的觀察者物件， 使他們可以自動更新自己。

設計模式——觀察者模式（C++實現）

ace mes des ret rtu cto pattern virt date 1 #include <iostream> 2 #include <vector> 3 #include <algorithm>

觀察者模式(Observer Pattern)（二）：HeadFirst中的氣象站的實現

att dex mov min first return 狀態 size sdi 1 觀察者模式的原理，首先由一個主題，當主題發送變化的時候，通知該主題的訂閱者 按照上面的分析我們來進行設計 1.抽象主題Subject public interface Subject {

iOS-知識梳理（觀察者模式-KVO、NSNotification的實現原理.KVC原理）

觀察者模式的定義：一個目標物件管理所有依賴於它的觀察者物件，並在它自身的狀態改變時主動通知觀察者物件。這個主動通知通常是通過呼叫各觀察者物件所提供的介面方法來實現的。觀察者模式較完美地將目標物件與觀察者物件解耦。 KVO基於runtime實現，當你觀察一個物件的時候，一個新類被動態建立繼承於

觀察者模式下es6的實現（自定義可監聽事件）

定義 觀察者模式：又叫釋出訂閱模式，多個觀察者可以實時監聽一個主題物件，而javascript中最常用的實現方式是事件觸發機制。 es6實現： 要知道需要有什麼東西，類和建構函式是es6中基本的物件結構 class BaseEvent { 　　constructor() {} } 首先類中要能儲

iOS-知識梳理（觀察者模式-KVO、NSNotification的實現原理）

觀察者模式的定義：一個目標物件管理所有依賴於它的觀察者物件，並在它自身的狀態改變時主動通知觀察者物件。這個主動通知通常是通過呼叫各觀察者物件所提供的介面方法來實現的。觀察者模式較完美地將目標物件與觀察者物件解耦。 KVO基於runtime實現，當你觀察一個物件的時候，一個新

設計模式之觀察者模式（Observe）-泛型擴充套件

設計模式之觀察者模式（Observer） 擴充套件部分是很精彩 意圖 定義物件間的一種一對多的依賴關係，當一個物件的狀態發生改變時，所有依賴於它的物件都得到通知並被自動更新。 場景 觀測天氣（

Unity如何實現網路通訊（三）：觀察者模式以及在網路模組的應用

    首先我們來說一下什麼叫觀察者模式。觀察者模式，顧名思義，就是觀察，那麼就會有觀察者和被觀察者，比如在軍隊中，所有的軍人要聽長官的指示，軍人就是觀察者，長官就是被觀察者，長官一聲號令：“向左轉！”，長官所有的監聽者就會執行向左轉的方法，那麼這就是一個觀察者模式的流程