c++ Delegate

最新推荐文章于 2023-03-30 22:53:07 发布
最新推荐文章于 2023-03-30 22:53:07 发布
阅读量118 收藏
点赞数
分类专栏： c++ 文章标签： c/c++ c# 

#ifndef DUMMYCLASS_H
#define DUMMYCLASS_H

namespace delegate
{
	class DummyClass{};
}

#endif
  

#ifndef METHODSTORAGE_H
#define METHODSTORAGE_H

#include "DummyClass.h"

namespace delegate
{
	class MethodStorage
	{
	public:
		typedef DummyClass GenericClass;
		typedef void (GenericClass::*GenericMemberFunctionPtr)();
		typedef void (*GenericFunctionPtr)();

		MethodStorage()
			:m_obj(0),
			m_member_fnptr(0),
			m_fnptr(0)
		{
		
		}

		inline bool operator == (MethodStorage const& other) const{return this->equals(other);}
		inline bool operator != (MethodStorage const& other) const{return !this->equals(other);}

		inline bool equals(MethodStorage const& other) const
		{
			return m_obj == other.m_obj 
				&& m_member_fnptr == other.m_member_fnptr
				&& m_fnptr == other.m_fnptr;
		}

	//protected:
		GenericClass *m_obj;
		GenericMemberFunctionPtr m_member_fnptr;
		GenericFunctionPtr m_fnptr;
	};
};

#endif
  

#ifndef METHODWRAPPER_H
#define METHODWRAPPER_H

#include "MethodStorage.h"

namespace delegate
{
	///This "Signature" is not a complete function pointer
	///corresponding signature to void (*)(int) is void(int)
	///and void (SomeClassType::*)(int) is void(int) as well
	template<typename Signature>
	class MethodWrapper;

	template<>
	class MethodWrapper< void () >
	{
	public:
		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType const& obj,void (MemberFunctionClass::*ptr)(void) const)
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)() >;
		}

		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType & obj,void (MemberFunctionClass::*ptr)(void)const )
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)() >;
		}

		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType & obj,void (MemberFunctionClass::*ptr)(void))
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)() >;
		}

		MethodWrapper(void (*ptr)(void))
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(this);
			m_method.m_fnptr = reinterpret_cast<MethodStorage::GenericFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeFunction< MethodWrapper , void (*)() >;
		}

		void operator()()
		{
			(this->*internal_call)(m_method.m_obj);
		}
	private:
		typedef void (MethodWrapper::*internal_call_type)(void*);
		MethodStorage m_method;

		internal_call_type internal_call;

		template<typename ClassType,typename FunctionPtrType>
		void executeMemberFunction(void* obj)
		{
			(reinterpret_cast<ClassType*>(obj)->*reinterpret_cast<FunctionPtrType>(m_method.m_member_fnptr))();
		}

		template<typename ClassType,typename FunctionPtrType>
		void executeFunction(void* obj)
		{
			(*reinterpret_cast<FunctionPtrType>(m_method.m_fnptr))();
		}
	};
	template<typename ReturnType> 
	class MethodWrapper< ReturnType () >
	{
	public:
		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType const& obj,ReturnType (MemberFunctionClass::*ptr)(void) const)
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , ReturnType (MemberFunctionClass::*)() >;
		}

		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType & obj,ReturnType (MemberFunctionClass::*ptr)(void)const )
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , ReturnType (MemberFunctionClass::*)() >;
		}

		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType & obj,ReturnType (MemberFunctionClass::*ptr)(void))
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , ReturnType (MemberFunctionClass::*)() >;
		}

		MethodWrapper(ReturnType (*ptr)(void))
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(this);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeFunction< MethodWrapper , ReturnType (*)() >;
		}

		ReturnType operator()()
		{
			return (this->*internal_call)(m_method.m_obj);
		}
	private:
		typedef void (MethodWrapper::*internal_call_type)(void);
		MethodStorage m_method;

		internal_call_type internal_call;

		template<typename ClassType,typename FunctionPtrType>
		ReturnType executeMemberFunction(void* obj)
		{
			return (reinterpret_cast<ClassType*>(obj)->*reinterpret_cast<FunctionPtrType>(m_method.m_member_fnptr))();
		}

		template<typename ClassType,typename FunctionPtrType>
		ReturnType executeFunction(void* obj)
		{
			return (*reinterpret_cast<FunctionPtrType>(m_method.m_fnptr))();
		}
	};
	template<typename ArgType0> 
	class MethodWrapper< void ( ArgType0 ) >
	{
	public:
		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType const& obj,void (MemberFunctionClass::*ptr)(ArgType0) const)
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(const_cast<ClassType*>(&obj));
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)(ArgType0) >;
		}

		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType & obj,void (MemberFunctionClass::*ptr)(ArgType0)const )
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)(ArgType0) >;
		}

		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType const& obj,void (MemberFunctionClass::*ptr)(ArgType0))
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(const_cast<ClassType*>(&obj));
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)(ArgType0) >;
		}

		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType & obj,void (MemberFunctionClass::*ptr)(ArgType0))
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)(ArgType0) >;
		}

		MethodWrapper(void (*ptr)(ArgType0))
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(this);
			m_method.m_fnptr = reinterpret_cast<MethodStorage::GenericFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeFunction< MethodWrapper , void (*)(ArgType0) >;
		}

		void operator()(ArgType0 arg0)
		{
			(this->*internal_call)(m_method.m_obj, arg0);
		}
	private:
		typedef void (MethodWrapper::*internal_call_type)(void*,ArgType0);
		MethodStorage m_method;

		internal_call_type internal_call;

		template<typename ClassType,typename FunctionPtrType>
		void executeMemberFunction(void* obj,ArgType0 arg0)
		{
			(reinterpret_cast<ClassType*>(obj)->*reinterpret_cast<FunctionPtrType>(m_method.m_member_fnptr))(arg0);
		}

		template<typename ClassType,typename FunctionPtrType>
		void executeFunction(void* obj,ArgType0 arg0)
		{
			(*reinterpret_cast<FunctionPtrType>(m_method.m_fnptr))(arg0);
		}
	};
	template<typename ReturnType,typename ArgType0> 
	class MethodWrapper< ReturnType ( ArgType0 ) >
	{
	public:
		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType const& obj,ReturnType (MemberFunctionClass::*ptr)(ArgType0) const)
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)(ArgType0) >;
		}

		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType & obj,ReturnType (MemberFunctionClass::*ptr)(ArgType0)const )
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)(ArgType0) >;
		}

		template<typename ClassType,typename MemberFunctionClass>
		MethodWrapper(ClassType & obj,ReturnType (MemberFunctionClass::*ptr)(ArgType0))
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(&obj);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeMemberFunction< ClassType , void (MemberFunctionClass::*)(ArgType0) >;
		}

		MethodWrapper(ReturnType (*ptr)(ArgType0))
		{
			m_method.m_obj = reinterpret_cast<MethodStorage::GenericClass*>(this);
			m_method.m_member_fnptr = reinterpret_cast<MethodStorage::GenericMemberFunctionPtr>(ptr);
			internal_call = &MethodWrapper::executeFunction< MethodWrapper , void (*)(ArgType0) >;
		}

		ReturnType operator()(ArgType0 arg0)
		{
			return (this->*internal_call)(m_method.m_obj,arg0);
		}
	private:
		typedef ReturnType (MethodWrapper::*internal_call_type)(void*,ArgType0);
		MethodStorage m_method;

		internal_call_type internal_call;

		template<typename ClassType,typename FunctionPtrType>
		ReturnType executeMemberFunction(void* obj,ArgType0 arg0)
		{
			return (reinterpret_cast<ClassType*>(obj)->*reinterpret_cast<FunctionPtrType>(m_method.m_member_fnptr))(arg0);
		}

		template<typename ClassType,typename FunctionPtrType>
		ReturnType executeFunction(void* obj,ArgType0 arg0)
		{
			return (*reinterpret_cast<FunctionPtrType>(m_method.m_fnptr))(arg0);
		}
	};
}

#endif
 

 

 

compiler:MinGW 4.5.2 / VC++2010

 

 

C#式的delegate的重点之一是省略掉类型信息.

http://www.codeproject.com/KB/cpp/ImpossiblyFastCppDelegate.aspx 写道 
class delegate
{
public:
    delegate()
        : object_ptr(0)
        , stub_ptr(0)
    {}

    template <class T, void (T::*TMethod)(int)>
    static delegate from_method(T* object_ptr)
    {
        delegate d;
        d.object_ptr = object_ptr;
        d.stub_ptr = &method_stub<T, TMethod>; // #1

        return d;
    }

    void operator()(int a1) const
    {
        return (*stub_ptr)(object_ptr, a1);
    }

private:
    typedef void (*stub_type)(void* object_ptr, int);

    void* object_ptr;
    stub_type stub_ptr;

    template <class T, void (T::*TMethod)(int)>
    static void method_stub(void* object_ptr, int a1)
    {
        T* p = static_cast<T*>(object_ptr);
        return (p->*TMethod)(a1); // #2

    }
};
 

 非常巧妙地隐藏掉了类型信息。但是本人对虚继承的委托还没有好的解决方法，也理解不了虚继承的成员函数的hack:http://www.codeproject.com/KB/cpp/FastDelegate.aspx

 

iteye_10111
关注
专栏目录
C++笔记之Delegate和委托构造(Delegating constructor)
小勇博客
12-10 1178
— 杭州 2023-12-10。
C++ 实现 C# delegate 机制
杂七杂八
12-15 1356
C# 里的 delegate C# 里的 delegate 作为语法特性的一部分，使用起来非常方便。 首先按照函数签名，声明一个 delegate 类型： delegate void DelegateType(); 之后就可以用这个 delegate 类型来声明 delegate 变量了。 DelegateType delegateMetods; 再之后，就可以用这个 delegate 类型的变量，来 注册 / 注销监听函数了。比如我们有两个函数 Test1,Test2 void Test1() {}
C++实现delegate
10-14
用C++做项目的时候，尤其是写客户端的时候经常会有事件回调的设计，一般的方式是使用虚函数表，用一个虚基类包含一系列的回调函数。但这种方式和C++11的lamda不兼容，为了更方便的实现事件回调机制，使用delegate是很不错的一种方式。
C++中实现委托（Delegate）
huangwei.pro
11-17 1596
<br />http://blog.huang-wei.com/2010/08/09/c%E4%B8%AD%E5%AE%9E%E7%8E%B0%E5%A7%94%E6%89%98%EF%BC%88delegate%EF%BC%89/<br /> C++中实现委托（Delegate）<br />公司的项目里有用到Don Clugston的FastDelegate，当时只知道是类似boost::function的东西，UI上当watcher用的比较多，所以也没去关注。今天想写个事件触发器时，突然想起这茬子，看来
C++中的delegate
胜利者的经验并不复杂,那就是寻找人生的关键点,并在关键时刻竭尽全力
09-13 4743
《以boost::function和boost:bind取代虚函数》，原文链接：http://blog.csdn.net/solstice/article/details/3066268 ，很多年前的一篇blog，感觉收获颇丰。 第一个问题，虚函数是否可以被取代？--完全可以。 虚函数一般是用来实现多态，或者说是接口与实现分析。可以直接拿作者的例子来举例：   上面可以说是对象装配的过
c++ delegate实现
ab3381的博客
08-26 175
废话不多说，上代码 #pragma once #include <mutex> #include <thread> template<typename T> class Lockable { private: T _data; mutable std::recursive_mutex _mutex; friend clas...
一个C++ delegate的实现
不亦快斋
11-28 1万+
更新说明：修改了借口，增加了对smart_ptr的支持。最近需要一个C++delegate的实现，比较接近C#的delegate的用法。翻遍了boost，虽然有相近的东西，但是，始终使用起来问题多多：function:的绑定方式倒也可以接受，成员函数调用的方式实在不爽。而且，同样的函数原型，native和member对应的function类型不同，不同class的相同原型的member funct
qt c++ delegate
最新发布
08-27
在Qt C++ 中，Delegate是一种强大的工具，它用于将数据模型（如QAbstractItemModel）的数据映射到界面控件上，简化了表格视图（QTableView）、列表视图（QListView）等组件与实际业务数据之间的交互。Delegate允许你...
c++ delegate用法
03-08
C++中的委托（delegate）是一种函数指针的高级形式，它可以将函数作为参数传递给其他函数或存储在数据结构中。委托提供了一种灵活的方式来实现回调机制和事件处理。 在C++中，可以使用函数指针、函数对象和Lambda...
C++中实现委托（delegate）
05-06
网上有很多关于C++ delegate机制的文章，但都讲的是函数指针的内容，上周就C++中实现C#的delegate机制的问题研究了好几天，查看了很多相关资料，才解决了问题，现将我写的C++ delegate测试程序贴出来，希望能帮到有需要的人。
C++ 委托 fastdelegate使用，实现类函数回调绑定
03-26
NULL 博文链接：https://cooker.iteye.com/blog/1176141
在C++中实现委托（Delegate）——普通函数（一）
斧冰
03-23 1057
为了一步步实现委托，同时也为了方便将目标问题拆解，我们采用先从普通函数入手，再到成员函数，逐步实现类似于C#中的委托。 首先，明确目标： 一、目标 #include <iostream> #include "CMultiDelegate.h" #include "CStaticDelegate.h" void Say() { printf("void Say(): Hello wo...
在 C/C++ 中实现委托（delegate）
liulilittle的博客
02-05 1万+
  相信使用过C#语言的人们，对于委托应该是记忆深刻，委托具有很多不错的特性，但最令人感到兴奋的是它可以简化很多复杂的开发同时具有低耦合与对象闭包的特性。    委托在C/C++中可以解决最直观的就有问题，一个是相同代码签名的成员函数与全局函数可以被一个委托调用的问题，在C/C++语言中我们在不借助委托的前提下，代码很难在不增加耦合与依赖的情况调用它们（无论这个依赖是隐式的还是显式的都会存在这个...
C++实现代理（delegate）
xiaoxiaoyusheng2012的专栏
05-08 1562
记不清出处了，实现代码是别人的，自己整理的 //delegate.h /*! @file @author Albert Semenov @date 11/2007 @module */ /* This file is part of MyGUI. MyGUI is free software: you can redistribute it and/or modify it under
C++中delegate(委托)的实现
我心飞翔
02-13 1398
delegate.h#ifndef WAN_DELEGATE_H#define WAN_DELEGATE_H   /** * @author Kevin Wan  * @date   06/30/2005 * Copyright (C) Kevin Wan */#include "threadingmodel.h"   namespace wan{namespace local{template
【UE·C++】虚幻引擎中的委托（代理) Delegate
记录日常开发的小问题备忘
10-17 2836
自从看了虚幻引擎的C++源代码，并使用虚幻C++开发了3个多月以来，心中对虚幻的技术团队有一种莫名的崇拜，没想到他们能将C++用的如此出神入化，希望可以站在巨人的肩膀上，继续砥砺前行。今天来总结一下虚幻中的委托。委托模式，在面向对象设计模式也是一种很常见的模式：它可以看做是函数的抽象，是函数的“类”。委托的实例将代表一个具体的函数，一个委托可以搭载多个方法，所有的方法被依次唤起，可以使委托对象所搭载的方法并不需要属于同一类。（网上找的简单的定义），它。
c++ fast Delegate 实现代码
热门推荐
yacper的专栏
02-23 1万+
 委托这种机制，只有当代码写多了，才会发现它多么有用，虽然设计模式里的模板方法很好，但为了实现它而进行大量的类重载有时候可能得不偿失，然而c++本省并不支持委托，以下是一个非常强大的委托实现代码，直接可以拿来大量使用的。 http://www.codeproject.com/KB/cpp/FastDelegate.aspx 另有一中译篇： 成员函数指针与高性
C++实现委托的几种方法（摘录）
H.R
08-13 608
You have an incredible number of choices to achieve delegates in C++. Here are the ones that came to my mind. Option 1 : functors: A function object may be created by implementing operator()
[UE C++] Delegate使用详解
qq_52179126的博客
03-30 3726
Delegate的使用方法总结终于告一段落，文章比较长，若有错误，欢迎指出。学疏才浅，还请见谅。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值