C#委托的C++实现

最新推荐文章于 2023-05-03 15:05:15 发布
最新推荐文章于 2023-05-03 15:05:15 发布
阅读量582 收藏 1
点赞数
分类专栏： C/C++ 文章标签： c# c++ object function delete wince
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java0774/article/details/5745276
版权

以前做开发时经常需要处理回调，但回调有时很不方便，所以那时实现了一个类似C#委托的东东。
这个东东一般可以使用回调替代，但有一种情况不好替代，类成员回调的声明往往类型未知，
这就是我要写这个东东的最主要动机。后来针对参数定制不灵活还有完善，但其实现没有个这简洁，
所以只发表这个最简洁的版本喽，吼吼！

如果哪位想传载本文,悉听尊便,如果能保留本文出处饿会很感谢.
http://kenny-office.blog.163.com/blog/static/307869272010010028561/
2010-7-19 02:29 严重厚道

 

 


// 文件名称: entrust.h
// 文件描述: 定义委托模板,使C++可以支持类似C#的委托语法.
// 文件作者: kenny
// 创建时间: 2006-8-8 16:36

// 修改记录:
// *  2006-10-12 11:46 修改不恰当的注释
// *  2006-10-12 11:49 去除对委托调用的异常捕获, 使用户可以自定义.
// *  2008-3-31 10:46:20 修改名字空间命名,const修饰及添加clear方法
// *  2008-5-23 11:24:00 重新设计了类型安全版的委托tentrust2
// *  2009-3-16 11:24:00 添加演示程序

//演示程序:
//
//#include <sstream>
//
//using namespace std;
//
//class TTest
//{
//public:
// bool CALL_ENTRUST test_m(int, bool) { return true; }
//};
//
//int CALL_ENTRUST test_g(const char* s, double& n) {
// istringstream iss(s);
// iss >> n;
// return 0;
//}
//
//typedef nsKLIB::tentrust<int, bool, bool>   TEntrust1;
//typedef nsKLIB::tentrust<const char*, double&, int> TEntrust2;
//
//void demo()
//{
// TTest test;
// TEntrust1 e1(&test, &TTest::test_m);
// TEntrust2 e2(&test_g);
//
// bool ret1 = e1(3, true); //相当与调用了test.test_m(), 实际使用时e1可以保存或传递到任何有效周期内的代码中调用.支持动态链接库.
//
// double outret = double();
// int ret2 = e2("35.023", outret); //相当于调用了test_g(), 实际使用时e1可以保存或传递到任何有效周期内的代码中调用.支持动态链接库.
//
//}
//

#if !defined(__ENTRUST_H_2006_8_8_KENNY__)
#define __ENTRUST_H_2006_8_8_KENNY__

namespace nsKLIB
{
#if defined(__WINVER__) || defined(_MSC_VER) || defined(__BORLANDC__)
//如果是WINCE或是WIN32平台需要指定一下参数栈操作方式
#define CALL_ENTRUST __stdcall
#else
#define CALL_ENTRUST
#endif

 namespace nsIMP
 {
  
  // 这个接口可以透明类成员委托和全局成员或静态成员委托间的差异
  
  template<typename _type_in,
   typename _type_out,
   typename _type_ret>
  struct tcaller {
   //调用处理例程
   virtual _type_ret call_function(_type_in __in, _type_out __out) = 0;
   //给出委托的复本
   virtual tcaller<_type_in, _type_out, _type_ret>* get_copy() = 0;
   //释放委托对象
   virtual void release() = 0;
  };

  
  // 类成员调用接口相关实现
  
  template<typename _type_object,
   typename _type_in,
   typename _type_out,
   typename _type_ret>
  struct tcaller_member_ref :
   public tcaller<_type_in, _type_out, _type_ret>
  {
   tcaller_member_ref(_type_object* obj, _type_ret (CALL_ENTRUST _type_object::* func)(_type_in, _type_out))
    : __object(obj), __func(func) {}

   virtual _type_ret call_function(_type_in arg_in, _type_out arg_out) {
    return (__func)? ((__object->*__func)(arg_in, arg_out)) : _type_ret();
   }

   virtual tcaller<_type_in, _type_out, _type_ret>* get_copy() {
    return new tcaller_member_ref<
     _type_object, _type_in, _type_out, _type_ret>(__object, __func);
   }

   virtual void release() { delete this; }

   _type_object* __object;
   _type_ret (CALL_ENTRUST _type_object::*__func)(_type_in, _type_out);
  };

  
  // 全局或静态成员接口相关实现
  
  template<typename _type_func,
   typename _type_in,
   typename _type_out,
   typename _type_ret>
  struct tcaller_global_ref : public tcaller<_type_in, _type_out, _type_ret> {
   tcaller_global_ref(_type_func func) : __func(func) {}

   virtual _type_ret call_function(_type_in arg_in, _type_out arg_out) {
    return ((__func)? __func(arg_in, arg_out) : _type_ret());
   }

   virtual tcaller<_type_in, _type_out, _type_ret>* get_copy() {
    return new tcaller_global_ref<
     _type_func, _type_in, _type_out, _type_ret>(__func);
   }

   virtual void release() { delete this; }

   _type_func __func;
  };

  
  // 委托实现模板
  
  template<typename _type_in,   //输入参数类型,用户可以自定义类型,其用途不限定为输入参数
   typename _type_out = void*,  //输出参数类型,用户可以自定义类型,其用途不限定为输出参数
   typename _type_ret = int>  //委托返回类型,用户可以自定义类型
  class tentrust2
  {
  public:
   typedef _type_in     tin;
   typedef _type_out     tout;
   typedef _type_ret     tret;
   typedef tentrust2<tin, tout, tret> tthis;

  public:
   tentrust2() : __call_ptr(0) {}

   //----------------------------------------------------------------------------------------//
   //通过类实例和类成员构造一个委托
   // 参数:
   //  object  程序入口的类实例
   //  func  程序入口的类成员偏移
   template<typename _type_object>
   explicit tentrust2(_type_object* object,
    tret (CALL_ENTRUST _type_object::*func)(tin, tout))
    : __call_ptr(new tcaller_member_ref<_type_object, tin, tout, tret>(object, func)) {}

   //----------------------------------------------------------------------------------------//
   //通过全局成员或静态成员构造一个委托
   // 参数:
   //  func  全局成员或静态成员地址
   explicit tentrust2(tret(CALL_ENTRUST *func)(tin, tout))
    : __call_ptr(new tcaller_global_ref<tret(CALL_ENTRUST*)(tin, tout), tin, tout, tret>(func)) {}

   //----------------------------------------------------------------------------------------//
   //这个就不多说了,拷贝构造函数
    tentrust2(const tentrust2<tin, tout, tret>& ins) : __call_ptr(
    (ins.__call_ptr) ? (ins.__call_ptr->get_copy()) : 0) {
     __call_ptr = (ins.__call_ptr) ? (ins.__call_ptr->get_copy()) : 0;
   }

   //----------------------------------------------------------------------------------------//
   //通过类实例和类成员使委托绑定到一个处理例程
   // 参数:
   //  object  处理例程的类实例
   //  func  处理例程的类成员偏移
   template<typename _type_object>
   bool plug(_type_object* object,
    tret(CALL_ENTRUST _type_object::*func)(tin, tout)) {
     this->clear();
     __call_ptr = new tcaller_member_ref<_type_object, tin, tout, tret>(object, func);
     return 0 != __call_ptr;
   }

   //----------------------------------------------------------------------------------------//
   //通过全局成员或静态成员使委托绑定到一个处理例程
   // 参数:
   //  func  全局成员或静态成员的函数地址
   bool plug(tret(CALL_ENTRUST *func)(tin, tout)) {
    this->clear();
    __call_ptr = new tcaller_global_ref<
     tret(CALL_ENTRUST*)(tin, tout), tin, tout, tret>(func);
    return 0 != __call_ptr;
   }

   //----------------------------------------------------------------------------------------//
   //这个也不多说了,拷贝操作符
   template<typename _type_in2, //输入参数类型
    typename _type_out2,  //输出参数类型
    typename _type_ret2>  //委托返回类型
    tthis& operator=(tentrust2<_type_in2, _type_out2, _type_ret2>& ins) {
     if( this != &ins ) {
      this->clear();
      __call_ptr = ((ins.__call_ptr)? ins.__call_ptr->get_copy() : 0);
     }
     return *this;
   }

   //----------------------------------------------------------------------------------------//
   ~tentrust2() { this->clear(); }

   //----------------------------------------------------------------------------------------//
   //调用委托绑定的例程,就像调用例程本身一样
   tret operator()(tin arg_in, tout arg_out) {
    return (__call_ptr)? __call_ptr->call_function(arg_in, arg_out) : tret(); }

   //----------------------------------------------------------------------------------------//
   //调用委托绑定的例程,就像调用例程本身一样
   tret operator()(tin arg_in) {
    return (__call_ptr)? __call_ptr->call_function(arg_in, tout()) : tret(); }

   //----------------------------------------------------------------------------------------//
   //清除委托到例程的绑定
   void clear() {
    if( __call_ptr ) {
     tcaller<tin, tout, tret>* tmp = __call_ptr;
     __call_ptr = 0;
     tmp->release();
    }
   }

   //----------------------------------------------------------------------------------------//
   //判断委托是否已经绑定到某一例程
   bool empty() const { return 0 == __call_ptr; }
   operator bool() const { return !empty(); }

  private:
   tcaller<tin, tout, tret>* __call_ptr;
  };

 }
 
 using namespace nsIMP;

#define tentrust tentrust2

 
 template<typename _type_object,
  typename _type_in,
  typename _type_out,
  typename _type_ret>
 tentrust<_type_in, _type_out, _type_ret>
  entrust_create(_type_object* o,
  _type_ret (CALL_ENTRUST _type_object::*f)(_type_in, _type_out)) {
   return tentrust<_type_in, _type_out, _type_ret>(o, f);
 }

} //namespace nsKLIB

#endif //__ENTRUST_H_2006_8_8_KENNY__

java0774
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在C++中实现C#的委托
BoweirrKing的专栏
02-01 1124
通过研究，这两天写了一个C++ 的Delegate。关键调用部分使用汇编写成，效率是可以保证的。同时支持32位和64位系统。 支持“+=”操作符构造委托链。 但是，目前不支持将“虚函数”作为委托的目标函数。普通成员函数和静态成员函数都可以的。 目前也不支持异步的委托。 基本用法如下： (其实我是重写了这文章中的例子：http://blog.csdn.net/cjl5678
C++：实现委托机制
Taopper的博客
08-17 732
为了解决GUI 跨线程操作界面的导致主线程崩溃的情况, C++ 11 终于推出了自己的thread 类thread 类提供detach() 的方法, 让worker线程也具备了操作GUI的能力.在GUI开发中, 通过使用function和thread等C++ 11 新特性,能够更便捷的开发出高质量的程序, 同时回避开发过程中的问题。...
在 C/C++ 中实现委托（delegate）
liulilittle的博客
02-05 9866
  相信使用过C#语言的人们，对于委托应该是记忆深刻，委托具有很多不错的特性，但最令人感到兴奋的是它可以简化很多复杂的开发同时具有低耦合与对象闭包的特性。    委托在C/C++中可以解决最直观的就有问题，一个是相同代码签名的成员函数与全局函数可以被一个委托调用的问题，在C/C++语言中我们在不借助委托的前提下，代码很难在不增加耦合与依赖的情况调用它们（无论这个依赖是隐式的还是显式的都会存在这个...
C++笔记-16-委托机制的实现
韩天衣的博客
03-21 1979
C++笔记-16-委托机制的实现 在C#中，有完善的委托可以存储成员函数。但是在C++中，我们需要自己利用C++特性去实现委托。 首先，我们要解决的问题就是如何存储成员函数指针，此外，对于每一个成员函数指针，他都需要一个类对象去调用它 此外，考虑到全局函数，他的存储方法又和成员函数不同，因此我们需要通过抽象类实现类型存储的多态化。 思路解读 委托抽象类 第一步，我们需要一个抽象类，作为任意委托类型的基类 class IDelegate { public: virtual ~IDelegate() {
c++实现c#委托机制
SunminpSun的专栏
11-13 759
看了两本关于设计模式的书，一本是用的java语言描写的《设计模式之禅》，另一本是用C#语言描述的《大话设计模式》，两本都不是我常用的C/C++，不过C++是面向对象的语言，当然你也可以用它编写面向过程的程序。        既然C++是面向对象的语言，那么所有的两本书讲的所有的设计模式都应该能够实现，只是实现的具体方法不一样而已，比如一个单例模式，用java实现的方法如下：     class
在C++实现委托
七彩狻猊
05-09 1892
<br />在前面提到回调了，那么现在就开始说委托吧。个人是这么理解委托的，就是一件事你不做或者不能做或者不想做，那么就委托给别人做，我只调用别人的函数接口就可以了，也就是我要实现一个功能，我只要接口，实际的实现委托给别人，突然有一天我要做的事的逻辑发生了变化，那么我也不需要更改自己的调用，只需要被委托者更换一下逻辑就可以了。同时，如果在一定的场合下要调用很多相同形式的函数，那么使用委托将很方便。<br />在设计模式中状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。委托也可以接受多个实
C#调用C++动态DLL
02-13
本文将详细探讨如何在C#中实现对C++动态DLL的调用。 首先，了解动态链接库（DLL）的基本概念。DLL是一种可执行文件，其中包含可供多个程序共享的函数和资源。它不是独立运行的，而是被其他程序加载并调用其功能。...
C# to C++ Converter
08-06
在实际使用过程中，"C# to C++ Converter"能够处理C#中的各种语法结构，包括类、接口、方法、属性、事件、委托、枚举、泛型等，并转换成C++对应的语法。同时，它还考虑到了C#特有的特性，如自动垃圾回收、匿名方法、...
c++实现委托和事件
11-23
这样，我们就使用C++的`std::function`和`std::bind`实现了类似于C#中的委托和事件机制。这种方法虽然没有C#那样的语法糖，但依然能够提供功能强大的回调管理和事件通知。在实际项目中，这种机制可以用于实现如UI...
C#调用c++.zip
03-03
本案例聚焦于"C#"和"C++"这两种编程语言之间的交互，主要通过动态链接库（DLL）实现。下面将详细阐述这个主题。 标题"C#调用c++.zip"表明，这是一个关于如何在C#应用中调用由C++编写的DLL的教程或示例。DLL是一种可...
C++中实现委托（delegate）
05-06
网上有很多关于C++ delegate机制的文章，但都讲的是函数指针的内容，上周就C++中实现C#的delegate机制的问题研究了好几天，查看了很多相关资料，才解决了问题，现将我写的C++ delegate测试程序贴出来，希望能帮到有需要的人。
C#委托与C++回调函数处理
01-30
告诉你怎么用C#委托处理dll中的回调函数。有几篇文档在里面
c#委托事件的实现
01-09
基于c#程序对c语言中的委托事件进行详细的分析与讲解
C#调用C++的代码
04-08
在C#代码中，我们需要定义一个与C++函数相对应的委托，并使用`[DllImport]`属性标记该委托，指定DLL的路径和函数名称。 2. **数据类型映射** C#和C++的数据类型并不完全相同，因此需要进行映射。例如，C++的`int`...
C++实现委托机制(一)
热门推荐
YzlCoder的记事本
05-14 2万+
如果你接触过C#,你就会觉得C#中的delegate(委托)十分灵巧，它的用法上和C\C++的函数指针很像，但是却又比C\C++的函数指针更加灵活。并且委托可以一对多，也就是可以注册多个函数，甚至是某个类的非静态成员函数。而实现事件消息机制【1】也十分依赖于委托机制。基于这样的目的，我们试着在C++上封装出这样的一个委托机制。
【项目三】C++实现事件委托
yyy11280335的博客
12-29 1065
前几天在学习设计模式中的观察者模式时发现需要用到一个十分巧妙的机制——事件委托，事件委托的匿名属性，可以使得通知者对象更新观察者对象时不需要依赖具体名称的函数，是一种降低系统耦合度的设计。我看的设计模式书是《大话设计模式》，里面使用C#举例的，C#中就有事件委托的机制，而我是学C++，无奈C++中没有事件委托的设计，虽然Qt中有类似的机制——信号与槽，但是总感觉技术不如掌握在自己手中好，索性自己了解并编写一套事件委托系统
C#委托、C++委托实现、C回调函数
遛遛马，务务农
05-03 1169
委托定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递
c# 委托 delegate
lookmoney的博客
05-27 250
c# 委托 delegate 的简单使用示例
C#中使用托管C++类，委托调用，以供托管C++类的成员函数回调的实现方式
ganmin167的博客
09-22 4379
简单介绍了在C#下面调用C++的托管类的成员函数，传入委托（函数指针），再在C++中回调C#的函数代码，
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、付费专栏及课程。

余额充值