C++实现委托机制之完整代码实现

最新推荐文章于 2022-08-17 17:46:03 发布
最新推荐文章于 2022-08-17 17:46:03 发布
阅读量311 收藏
点赞数
分类专栏： C++ 委托

头文件 MyDelegate.h 代码如下：

#pragma once

#include <typeinfo.h>
#include <list>
#include <vector>

namespace Delegate
{

	// IDelegate   提供接口的基类

	template<typename ReturnType, typename ...ParamType>
	class IDelegate
	{
	public:
		IDelegate(){}
		virtual ~IDelegate(){}
		virtual bool isType(const std::type_info& _type) = 0;
		virtual ReturnType invoke(ParamType ... params) = 0;
		virtual bool compare(IDelegate<ReturnType, ParamType...> *_delegate) const = 0;
	};

	
	//StaticDelegate 普通函数的委托

	template<typename ReturnType, typename ...ParamType>
	class CStaticDelegate :
		public IDelegate<ReturnType, ParamType...>
	{
	public:

		typedef  ReturnType(*Func)(ParamType...);

		CStaticDelegate(Func _func) : mFunc(_func) { }

		virtual bool isType(const std::type_info& _type) { return typeid(CStaticDelegate<ReturnType, ParamType...>) == _type; }

		virtual ReturnType invoke(ParamType ... params) { return mFunc(params...); }

		virtual bool compare(IDelegate<ReturnType, ParamType ...> *_delegate)const
		{
			if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate<ReturnType, ParamType ...>))) return false;
			CStaticDelegate<ReturnType, ParamType ...> * cast = static_cast<CStaticDelegate<ReturnType, ParamType ...>*>(_delegate);
			return cast->mFunc == mFunc;
		}

		virtual ~CStaticDelegate(){}
	private:
		Func mFunc;
	};


	//普通函数的委托特化版本
	template<typename ReturnType, typename ...ParamType>
	class CStaticDelegate<ReturnType(*)(ParamType ...)> :
		public IDelegate<ReturnType, ParamType ...>
	{
	public:

		//定义 Func 为 void (void) 函数类型指针。
		typedef  ReturnType(*Func)(ParamType...);

		CStaticDelegate(Func _func) : mFunc(_func) { }

		virtual bool isType(const std::type_info& _type) { return typeid(CStaticDelegate<ReturnType(*)(ParamType ...)>) == _type; }

		virtual ReturnType invoke(ParamType ... params) { return mFunc(params...); }

		virtual bool compare(IDelegate<ReturnType, ParamType ...> *_delegate)const
		{
			if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate<ReturnType(*)(ParamType ...)>))) return false;
			CStaticDelegate<ReturnType(*)(ParamType ...)> * cast = static_cast<CStaticDelegate<ReturnType(*)(ParamType ...)>*>(_delegate);
			return cast->mFunc == mFunc;
		}

		virtual ~CStaticDelegate(){}
	private:
		Func mFunc;
	};

	//成员函数委托
	template<typename T, typename ReturnType, typename ...ParamType>
	class CMethodDelegate :
		public IDelegate<ReturnType, ParamType...>
	{
	public:
		typedef ReturnType(T::*Method)(ParamType...);

		CMethodDelegate(T * _object, Method _method) : mObject(_object), mMethod(_method) { }

		virtual bool isType(const std::type_info& _type) { return typeid(CMethodDelegate<T, ReturnType, ParamType...>) == _type; }

		virtual ReturnType invoke(ParamType...params)
		{
			(mObject->*mMethod)(params...);
		}

		virtual bool compare(IDelegate<ReturnType, ParamType...> *_delegate) const
		{
			if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate<ReturnType, ParamType...>))) return false;
			CMethodDelegate<ReturnType, ParamType...>* cast = static_cast<CMethodDelegate<ReturnType, ParamType...>*>(_delegate);
			return cast->mObject == mObject && cast->mMethod == mMethod;
		}

		CMethodDelegate(){}
		virtual ~CMethodDelegate(){}
	private:
		T * mObject;
		Method mMethod;
	};

	//成员函数委托特化
	template<typename T, typename ReturnType, typename ...ParamType>
	class CMethodDelegate<T,ReturnType (T:: *)(ParamType...)> :
		public IDelegate<ReturnType, ParamType...>
	{
	public:
		typedef ReturnType(T::*Method)(ParamType...);

		CMethodDelegate(T * _object, Method _method) : mObject(_object), mMethod(_method) { }

		virtual bool isType(const std::type_info& _type) { return typeid(CMethodDelegate<T,ReturnType(T:: *)(ParamType...)>) == _type; }

		virtual ReturnType invoke(ParamType...params)
		{
			return (mObject->*mMethod)(params...);
		}

		virtual bool compare(IDelegate<ReturnType, ParamType...> *_delegate) const
		{
			if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate<T, ReturnType(T:: *)(ParamType...)>))) return false;
			CMethodDelegate<T, ReturnType(T:: *)(ParamType...)>* cast = static_cast<CMethodDelegate<T, ReturnType(T:: *)(ParamType...)>*>(_delegate);
			return cast->mObject == mObject && cast->mMethod == mMethod;
		}

		CMethodDelegate(){}
		virtual ~CMethodDelegate(){}
	private:
		T * mObject;
		Method mMethod;
	};

	


	//多播委托
	template<typename ReturnType, typename ...ParamType>
	class CMultiDelegate
	{
		
	public:
		
		typedef std::list<IDelegate<ReturnType, ParamType...>*> ListDelegate;
		typedef typename ListDelegate::iterator ListDelegateIterator;
		typedef typename ListDelegate::const_iterator ConstListDelegateIterator;

		CMultiDelegate() { }
		~CMultiDelegate() { clear(); }

		bool empty() const
		{
			for (ConstListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
			{
				if (*iter) return false;
			}
			return true;
		}

		void clear()
		{
			for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
			{
				if (*iter)
				{
					delete (*iter);
					(*iter) = nullptr;
				}
			}
		}


		CMultiDelegate<ReturnType, ParamType...>& operator+=(IDelegate<ReturnType, ParamType...>* _delegate)
		{
			for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
			{
				if ((*iter) && (*iter)->compare(_delegate))
				{
					delete _delegate;
					return *this;
				}
			}
			mListDelegates.push_back(_delegate);
			return *this;
		}

		CMultiDelegate<ReturnType, ParamType...>& operator-=(IDelegate<ReturnType, ParamType...>* _delegate)
		{
			for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
			{
				if ((*iter) && (*iter)->compare(_delegate))
				{
					if ((*iter) != _delegate) delete (*iter);       //避免同一个地址被delete两次
					(*iter) = 0;
					break;
				}
			}
			delete _delegate;
			return *this;
		}

		std::vector<ReturnType> operator()(ParamType... params)
		{
			ListDelegateIterator iter = mListDelegates.begin();
			std::vector<ReturnType> _Results;
			while (iter != mListDelegates.end())
			{
				if (0 == (*iter))
				{
					iter = mListDelegates.erase(iter);
				}
				else
				{
					_Results.push_back((*iter)->invoke(params...));
					++iter;
				}
			}
			return _Results;
		}
	private:
		CMultiDelegate<ReturnType, ParamType...>(const CMultiDelegate& _event);
		CMultiDelegate<ReturnType, ParamType...>& operator=(const CMultiDelegate& _event);

	private:
		ListDelegate mListDelegates;
	};

	template< typename ...ParamType>
	class CMultiDelegate<void, ParamType...>
	{

	public:

		typedef std::list<IDelegate<void, ParamType...>*> ListDelegate;
		typedef typename ListDelegate::iterator ListDelegateIterator;
		typedef typename ListDelegate::const_iterator ConstListDelegateIterator;

		CMultiDelegate() { }
		~CMultiDelegate() { clear(); }

		bool empty() const
		{
			for (ConstListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
			{
				if (*iter) return false;
			}
			return true;
		}

		void clear()
		{
			for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
			{
				if (*iter)
				{
					delete (*iter);
					(*iter) = nullptr;
				}
			}
		}

		CMultiDelegate<void, ParamType...>& operator+=(IDelegate<void, ParamType...>* _delegate)
		{
			for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
			{
				if ((*iter) && (*iter)->compare(_delegate))
				{
					delete _delegate;
					return *this;
				}
			}
			mListDelegates.push_back(_delegate);
			return *this;
		}

		CMultiDelegate<void, ParamType...>& operator-=(IDelegate<void, ParamType...>* _delegate)
		{
			for (ListDelegateIterator iter = mListDelegates.begin(); iter != mListDelegates.end(); ++iter)
			{
				if ((*iter) && (*iter)->compare(_delegate))
				{
					if ((*iter) != _delegate) delete (*iter);       //避免同一个地址被delete两次
					(*iter) = 0;
					break;
				}
			}
			delete _delegate;
			return *this;
		}

		void operator()(ParamType... params)
		{
			ListDelegateIterator iter = mListDelegates.begin();
			while (iter != mListDelegates.end())
			{
				if (0 == (*iter))
				{
					iter = mListDelegates.erase(iter);
				}
				else
				{
					(*iter)->invoke(params...);
					++iter;
				}
			}
		}
	private:
		CMultiDelegate<void, ParamType...>(const CMultiDelegate& _event);
		CMultiDelegate<void, ParamType...>& operator=(const CMultiDelegate& _event);

	private:
		ListDelegate mListDelegates;
	};





	template< typename T>
	CStaticDelegate<T>* newDelegate(T func)
	{
		return new CStaticDelegate<T>(func);
	}
	template< typename T,typename F>
	CMethodDelegate<T,F>* newDelegate(T * _object, F func)
	{
		return new CMethodDelegate<T, F>(_object, func);
	}
}

源文件 main.cpp 代码如下： 

int _tmain(int argc, _TCHAR* argv[])
{
	CMultiDelegate<void,int> e;              //void(int)

	e += newDelegate([](int a){ printf("这是lambda表达式\n"); });  //请尽量不要使用这种方式。
	e -= newDelegate([](int a){ printf("这是lambda表达式\n"); });  //这样是无法注销的。因为上面那个lambda表达式和下面这个类型不一样！！
	//请使用下面这种方式：
	auto func = newDelegate([](int a){ printf("这是lambda表达式\n"); });;

	e += func;
	e -= func;

	return 0;
}


起个名字真的好难啊
关注
专栏目录
C++中实现委托（delegate）
05-06
网上有很多关于C++ delegate机制的文章，但都讲的是函数指针的内容，上周就C++中实现C#的delegate机制的问题研究了好几天，查看了很多相关资料，才解决了问题，现将我写的C++ delegate测试程序贴出来，希望能帮到有需要的人。
C++实现委托机制(二)
YzlCoder的记事本
05-15 7921
上一篇文章已经介绍了如何构建一个无参数无返回值的函数指针的委托,这篇文章将对上一文章所述委托进行扩展，使得可以注册任意函数指针，不过再讲篇内容之前先要介绍一下实现这个功能所需要了解的C++11的一个新特性———可变参数模板。
C++实现委托机制(一)
热门推荐
YzlCoder的记事本
05-14 2万+
如果你接触过C#,你就会觉得C#中的delegate(委托)十分灵巧，它的用法上和C\C++的函数指针很像，但是却又比C\C++的函数指针更加灵活。并且委托可以一对多，也就是可以注册多个函数，甚至是某个类的非静态成员函数。而实现事件消息机制【1】也十分依赖于委托机制。基于这样的目的，我们试着在C++上封装出这样的一个委托机制。
C++实现委托机制之完整代码实现(二)
起个名字好难啊
05-02 452
头文件 MyDelegate.h 代码如下： #include #include #include template class IDelegate { public: IDelegate(){} virtual ~IDelegate(){} virtual bool isType(const std::type_info& _type) = 0; virtual ReturnTy
C++实现的委托机制
taoqilin的专栏
03-28 1291
转载 C++实现的委托机制1.引言下面的委托实现使用的MyGUI里面的委托实现，MyGUI是一款强大的GUI库，想理解更多的MyGUI信息，猛击这里http://mygui.info/ 最终的代码可以在这里下载：http://download.csdn.net/detail/gouki04/3641328  我们的目标是要实现一个跟.NET几乎完全一样的委托，使用简单，支持多播，可以添加删除委托。...
c++实现委托
05-29
在给定的文件中，`CString.hpp`可能定义了一个名为`CString`的类，这个类可能实现了字符串相关的操作，并且可能通过委托机制来扩展其功能。`FastDelegate.hxx`和`FastDelegateBind.hxx`可能包含了快速委托的实现，...
c++实现委托和事件
11-23
这样，我们就使用C++的`std::function`和`std::bind`实现了类似于C#中的委托和事件机制。这种方法虽然没有C#那样的语法糖，但依然能够提供功能强大的回调管理和事件通知。在实际项目中，这种机制可以用于实现如UI...
C++实现委托及分析
12-22
近对编程语言的委托机制产生了浓厚的兴趣，C#，Objective-c的委托机制已经是各自强有力的编程规范工具，以下文字和代码是我近日对委托机制的理解，不妥之处，请及时指出。 　自我感觉C#的委托针对的对象是函数，...
C++11 function 委托机制 观察者模式，适用于界面开发，lambda表达式
03-22
在C++编程中，函数委托（Function Delegate）是一种机制，允许我们将一个函数或者函数对象绑定到另一个函数，形成一种回调的方式。C++11引入了委托的概念，这大大增强了C++的灵活性，尤其是在处理事件驱动编程和设计...
c++观察者模式与委托机制的结合
03-29
2. 委托机制：将任务或职责分配给其他对象，实现代码的解耦和灵活性。 3. Qt框架：提供信号和槽机制，实现观察者模式的一种C++实现。 4. 宏定义：用于简化无参数和多参数委托的创建和使用，提高代码的可读性和可维护...
在你的C++程序里实现委托
cambest的专栏
04-12 1992
在你的C<!-- p.MsoNormal {mso-style-parent:""; margin-bottom:.0001pt; text-align:justify; text-justify:inter-ideograph; font-size:10.5pt; font-family:"Times New Roman"; m
C++实现的委托机制（二）
weixin_30695195的博客
10-03 73
C++实现的委托机制（二） 作者：gouki04(啊古) 撰写日期：2011-09-27 博客链接：http://blog.csdn.net/gouki04 1.实现任意参数的函数委托 按上一篇文章的方法，你已经可以使用无参数的函数委托了。当然，这远远不够。要实现任意参数的函数委托，这里的任意参数包括任意个数和任意类型。任意类型这个容易解决，使用模板就行，但任意参数个数呢？ ...
在C++实现委托
fly_on_grass的专栏
10-23 575
在前面提到回调了，那么现在就开始说委托吧。个人是这么理解委托的，就是一件事你不做或者不能做或者不想做，那么就委托给别人做，我只调用别人的函数接口就可以了，也就是我要实现一个功能，我只要接口，实际的实现委托给别人，突然有一天我要做的事的逻辑发生了变化，那么我也不需要更改自己的调用，只需要被委托者更换一下逻辑就可以了。同时，如果在一定的场合下要调用很多相同形式的函数，那么使用委托将很方便。 在设计模
C++：实现委托机制
Taopper的博客
08-17 763
为了解决GUI 跨线程操作界面的导致主线程崩溃的情况, C++ 11 终于推出了自己的thread 类thread 类提供detach() 的方法, 让worker线程也具备了操作GUI的能力.在GUI开发中, 通过使用function和thread等C++ 11 新特性,能够更便捷的开发出高质量的程序, 同时回避开发过程中的问题。...
C++实现的委托机制(2)
古的博客
10-08 2125
C++实现的委托机制(2) 1.实现任意参数的函数委托 按上一篇文章的方法，你已经可以使用无参数的函数委托了。当然，这远远不够。要实现任意参数的函数委托，这里的任意参数包括任意个数和任意类型。任意类型这个容易解决，使用模板就行，但任意参数个数呢？ 注：最终的实现代码可以
用C++实现委托
zergbird的专栏
06-30 1199
本来是一篇csdn上的文章 所谓委托就是一个函数可以加上另外一个函数 然后运行这个函数的时候另外一个函数也跟着运行，是c#的机制把（文章里这么说的）。 新瓶旧酒而已，我看和java里面stream的实现也差不多。。。 这些是废话，我注意无论c#还是这个文章，委托机制串的函数类型都是一样的， 当然这个一般是足够了但是追求一下技术，能不能实现不一样的函数类型串连？  难点本身是如何解析和记录
C++实现委托
SzMing
11-09 452
一直以来总觉的C#的委托机制很好用。因为主要是做C++开发的。所以总是在想能不能在c++下实现下委托机制。先前也实现过几个版本。有的是通过传入对象指针和成员函数的指针的方式，有的是通过模板方式实现的。但这些实现都是在使用是显得很麻烦。要不写出的代码很臃肿。这和我一向的风格很不一致。研究了很久终于有了又一个更好的方案。不敢独享。让大家来指点一下。 代码如下： [cpp]
C++实现C#委托机制
最新发布
06-10
C++ 并没有原生的委托机制，但可以通过函数指针和对象指针来模拟委托机制。 在 C++ 中，函数指针可以作为参数传递和返回值，可以使用函数指针来实现委托的功能。而对象指针可以用于保存对象的状态和数据，也可以用于调用对象的成员函数。 以下是一个简单的 C++ 示例代码，演示了如何通过函数指针和对象指针来实现委托机制： ```cpp #include <iostream> #include <functional> using namespace std; class Delegate { public: void (*func)(void*); // 函数指针 void* obj; // 对象指针 void Invoke() { func(obj); // 调用函数指针 } }; class Test { public: void Print() { cout << "Hello, world!" << endl; } }; void PrintTest(void* obj) { Test* test = (Test*)obj; // 将对象指针转换为 Test 类型指针 test->Print(); // 调用对象的成员函数 } int main() { Test test; Delegate delegate; delegate.func = PrintTest; delegate.obj = &test; delegate.Invoke(); // 调用委托 return 0; } ``` 在这个示例代码中，我们定义了一个 `Delegate` 类，其中包含了一个函数指针和一个对象指针。`Invoke` 函数用于调用委托。我们还定义了一个 `Test` 类，其中包含了一个成员函数 `Print`。在 `main` 函数中，我们创建了一个 `Test` 对象 `test`，并创建了一个 `Delegate` 对象 `delegate`，将 `PrintTest` 函数的地址和 `test` 对象的地址分别赋值给 `Delegate` 对象的函数指针和对象指针。最后，我们通过 `delegate.Invoke()` 调用委托，实际上就是调用了 `PrintTest` 函数，并将 `test` 对象传递给了该函数，从而调用了 `Test` 对象的 `Print` 成员函数。 需要注意的是，这只是一个简单的示例，实际的委托机制可能更加复杂，并且需要考虑线程安全等问题。如果需要使用委托机制，建议使用现有的 C++ 第三方库或框架，如 Boost、Qt 等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值