用 C++ 实现 C# 中的 委托/事件 (1-delegateEMU.cpp)

最新推荐文章于 2020-12-31 14:02:38 发布
最新推荐文章于 2020-12-31 14:02:38 发布
阅读量802 收藏 1
点赞数
文章标签： c++ c# functor each object null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coolcch/article/details/5379
版权

前两天看程序员杂志
看到关于 C# 中的委托/事件
觉得用起来好像是挺方便的
本人热衷于 C++
想想用 C++ 来模拟似乎也可以
于是就有了下面的代码...
(VC6 不支持偏特化 本人工作环境就是 VC6 痛啊~~~)

没有返回值的函数用 delegate
否则就用 delegate_rt
functor 也一样 functorN/functorN_rt
delegate 的模板参数可以是函数指针(非成员函数)
也可以是 functor
还可以是 delegate
functor 可用 make_functor/make_functor_rt 来生成
要是有偏特化 就可以去掉讨厌的 _rt 了 :(

关于委托 boost里有现成的
不过可能 VC6 里用不了

这些代码旨在个人研究
如果大家发现其中问题 希望能指出

//filename: delegateEMU.cpp
#include <stdio.h>

#pragma warning(disable:4786)

#include "delegate.h"
#include "event.h"
#include "functor.h"
#include <functional>

class MyEventArgs : public EventArgs
{
public:
  MyEventArgs(const char* Context = "") : context(Context) {}
  const char* context;
};

typedef delegate<void (*)(object, MyEventArgs&)> EventHandler1;
typedef delegate<functor2<object, MyEventArgs&> > EventHandler2;

class Provider
{
  public:  event<EventHandler1> OkClick1;
  public:  event<EventHandler2> OkClick2;
};

static void global_Process_OkClick(object source, MyEventArgs& e)
{
  printf("global_Process_OkClick, /t%s/n", e.context);
}

class Master_base
{
public:
  public: Provider pro;
  public: Master_base()
  {
    pro.OkClick1 += EventHandler1(static_Process_OkClick);

    pro.OkClick2 += EventHandler2(
      make_functor(this, &Master_base::Process_OkClick));
    pro.OkClick2 += EventHandler2(
      make_functor(&Master_base::static_Process_OkClick));

    pro.OkClick2 += EventHandler2(
      make_functor(global_Process_OkClick));
  }
  protected: void Process_OkClick(object source, MyEventArgs& e)
  {
    printf("       Process_OkClick, /t%s/n", e.context);
  }
  public: static void static_Process_OkClick(object source, MyEventArgs& e)
  {
    printf("static_Process_OkClick, /t%s/n", e.context);
  }
  public: virtual void test_virtual() const
  {
    printf("Master_base::test_virtual const/n");
  }
  public: void mem_func__()
  {
    printf("Master_base::mem_func__/n");
  }
  public: void mem_func__int(int x)
  {
    printf("Master_base::mem_func__int %d/n", x);
  }
  public: void mem_func__int_str(int x, const char* str)
  {
    printf("Master_base::mem_func__int %d %s/n", x, str);
  }
  public: int mem_func_int_()
  {
    printf("Master_base::mem_func_int_/n");
    return 123;
  }
  public: int mem_func_int_int(int x)
  {
    printf("Master_base::mem_func_int_int %d/n", x);
    return x;
  }
  public: int mem_func_int_int_str(int x, const char* str)
  {
    printf("Master_base::mem_func_int_int %d %s/n", x, str);
    return x;
  }
};

class Master_derived: public Master_base
{
  public: Master_derived()
  {
    pro.OkClick1 += EventHandler1(static_Process_OkClick_Myself);

    pro.OkClick2 += EventHandler2(
      make_functor(this, &Master_derived::Process_OkClick_Myself));
    pro.OkClick2 -= EventHandler2(
      make_functor((Master_base*)this, &Master_base::Process_OkClick));
    pro.OkClick2 -= EventHandler2(
      make_functor(this, &Master_derived::Process_OkClick_Myself1));
    pro.OkClick2 += EventHandler2(
      make_functor(&Master_derived::static_Process_OkClick_Myself));

    pro.OkClick2 -= EventHandler2(
      make_functor(global_Process_OkClick));
  }
  protected: void Process_OkClick_Myself(object source, MyEventArgs& e)
  {
    printf("       Process_OkClick_Myself, /t%s/n", e.context);
  }
  private: void Process_OkClick_Myself1(object source, MyEventArgs& e)
  {
    printf("       Process_OkClick_Myself1, /t%s/n", e.context);
  }
  static void static_Process_OkClick_Myself(object source, MyEventArgs& e)
  {
    printf("static_Process_OkClick_Myself, /t%s/n", e.context);
  }
  public: virtual void test_virtual() const
  {
    printf("Master_derived::test_virtual const/n");
  }
};

class MainClass
{
public:
  void Main()
  {
    Master_base example1;
    Master_derived example2;
    printf("  example1.pro.OkClick1:/n");
    example1.pro.OkClick1(this, MyEventArgs("example1.pro.OkClick1"));
    printf("  example2.pro.OkClick1:/n");
    example2.pro.OkClick1(this, MyEventArgs("example2.pro.OkClick1"));
    printf("/n");
    printf("  example1.pro.OkClick2:/n");
    example1.pro.OkClick2(this, MyEventArgs("example1.pro.OkClick2"));
    printf("  example2.pro.OkClick2:/n");
    example2.pro.OkClick2(this, MyEventArgs("example2.pro.OkClick2"));
  }
};

void testfunc__()
{
  printf("testfunc__/n");
}

void testfunc__int(int i)
{
  printf("testfunc__int %d/n", i);
}

void testfunc__int_str(int i, const char* j)
{
  printf("testfunc__int_str %d %s/n", i, j);
}

int testfunc_int_()
{
  printf("testfunc_int_/n");
  return 111;
}

int testfunc_int_int(int i)
{
  printf("testfunc_int_int %d/n", i);
  return i;
}

int testfunc_int_int_str(int i, const char* j)
{
  printf("testfunc_int_int_str %d %s/n", i, j);
  return i;
}

typedef void (*func__)();
typedef void (*func__int)(int);
typedef void (*func__int_str)(int, const char*);

typedef int (*func_int_)();
typedef int (*func_int_int)(int);
typedef int (*func_int_int_str)(int, const char*);

int main()
{
  printf("event:/n");
  MainClass().Main();



  printf("/n functor:/n");
  Master_base mb;
  Master_derived md;



  printf("/n  func__:/n");
  delegate<func__> ffunc__(testfunc__);
  ffunc__ = delegate<func__>(testfunc__);
  ffunc__ -= delegate<func__>(testfunc__);
  ffunc__ += delegate<func__>(testfunc__);
  ffunc__ = ffunc__ - delegate<func__>(testfunc__);
  ffunc__ = ffunc__ + delegate<func__>(testfunc__);
  ffunc__ = delegate<func__>(testfunc__) + ffunc__;
  ffunc__ = testfunc__;
  ffunc__ -= testfunc__;
  ffunc__ += testfunc__;
  ffunc__ = ffunc__ - testfunc__;
  ffunc__ = ffunc__ + testfunc__;
  ffunc__ = testfunc__ + ffunc__;
  ffunc__();

  printf("  functor.func__:/n");
  delegate<functor0> ffunc__1(make_functor(testfunc__));
  ffunc__1 += make_functor(&mb, &Master_base::mem_func__);
  ffunc__1();


  printf("/n  func__int:/n");
  delegate<func__int> ffunc__int(testfunc__int);
  ffunc__int(888);

  printf("  functor.func__int:/n");
  delegate<functor1<int> > ffunc__int1(make_functor(testfunc__int));
  ffunc__int1 += make_functor(&mb, &Master_base::mem_func__int);
  ffunc__int1(777);


  printf("/n  func__int_str:/n");
  delegate<func__int_str> ffunc__int_str(testfunc__int_str);
  ffunc__int_str(888, "ccc");

  printf("  functor.func__int_str:/n");
  delegate<functor2<int, const char*> > 
    ffunc__int_str1(make_functor(testfunc__int_str));
  ffunc__int_str1 += make_functor(&mb, &Master_base::mem_func__int_str);
  ffunc__int_str1(777, "hhh");



  printf("/n  func_int_:/n");
  delegate_rt<int, func_int_> ffunc_int_(testfunc_int_);
  printf("ffunc_int_()=%d/n", ffunc_int_());

  printf("  functor.func_int_:/n");
  delegate_rt<int, functor0_rt<int> > 
    ffunc_int_1(make_functor_rt(testfunc_int_));
  printf("ffunc_int_1()=%d/n", ffunc_int_1());
  ffunc_int_1 -= make_functor_rt(testfunc_int_);
  ffunc_int_1 += make_functor_rt(&mb, &Master_base::mem_func_int_);
  printf("ffunc_int_1()=%d/n", ffunc_int_1());


  printf("/n  func_int_int:/n");
  delegate_rt<int, func_int_int> ffunc_int_int(testfunc_int_int);
  printf("ffunc_int_int()=%d/n", ffunc_int_int(888));

  printf("  functor.func_int_int:/n");
  delegate_rt<int, functor1_rt<int, int> > 
    ffunc_int_int1(make_functor_rt(testfunc_int_int));
  printf("ffunc_int_int1()=%d/n", ffunc_int_int1(777));
  ffunc_int_int1 -= make_functor_rt(testfunc_int_int);
  ffunc_int_int1 += make_functor_rt(&mb, &Master_base::mem_func_int_int);
  printf("ffunc_int_int1()=%d/n", ffunc_int_int1(777));


  printf("/n  func_int_int_str:/n");
  delegate_rt<int, func_int_int_str> ffunc_int_int_str(testfunc_int_int_str);
  printf("ffunc_int_int_str()=%d/n", ffunc_int_int_str(888, "ccc"));

  printf("  functor.func_int_int_str:/n");
  delegate_rt<int, functor2_rt<int, int, const char*> > 
    ffunc_int_int_str1(make_functor_rt(testfunc_int_int_str));
  printf("ffunc_int_int_str1()=%d/n", ffunc_int_int_str1(777, "hhh"));
  ffunc_int_int_str1 -= make_functor_rt(testfunc_int_int_str);
  ffunc_int_int_str1 += make_functor_rt(&mb, &Master_base::mem_func_int_int_str);
  printf("ffunc_int_int_str1()=%d/n", ffunc_int_int_str1(777, "hhh"));



  printf("/nstatic function size:/t%d/n", 
    sizeof(&global_Process_OkClick));
  printf("member function size:/t%d/n", 
    sizeof(&Master_base::mem_func__));
  printf("virtual member function size:/t%d/n", 
    sizeof(&Master_base::test_virtual));
  printf("/n");

  delegate<functor0> ftest_virtual;
  ftest_virtual = delegate<functor0>(ffunc__1)
                + delegate<functor0>(make_functor((Master_base*)&md, 
                                     &Master_base::test_virtual));
  ftest_virtual();
  printf("  test_virtual2:/n");
  ftest_virtual = ftest_virtual
                - make_functor(&md, &Master_derived::test_virtual);
  ftest_virtual = ftest_virtual
                + make_functor(&mb, &Master_base::test_virtual);
  ftest_virtual = make_functor(&mb, &Master_base::test_virtual) 
                + ftest_virtual;
  ftest_virtual();

  printf("/n  Test make_functor global:/n");
  EventHandler2 teststatic1(make_functor(&global_Process_OkClick));
  teststatic1((object)NULL, MyEventArgs());

  MyEventArgs e;
  functor2<object, MyEventArgs&> 
    teststatic2(make_functor(&global_Process_OkClick));
  teststatic2((object)NULL, e);
  make_functor(&global_Process_OkClick)(NULL, e);

  printf("/n  Test make_functor static member:/n");
  EventHandler2 teststatic3(make_functor(&Master_base::static_Process_OkClick));
  teststatic3((object)NULL, MyEventArgs());

  functor2<object, MyEventArgs&> 
    teststatic4(make_functor(&Master_base::static_Process_OkClick));
  teststatic4((object)NULL, e);
  make_functor(&Master_base::static_Process_OkClick)(NULL, e);

  std::vector<int> for_each_test(1, 1);
  for_each_test.push_back(2);
  for_each_test.push_back(3);
  printf("/n  for_each test ffunc__int:/n");
  std::for_each(for_each_test.begin(), for_each_test.end(), ffunc__int);
  printf("/n  for_each test ffunc__int1:/n");
  std::for_each(for_each_test.begin(), for_each_test.end(), ffunc__int1);
  printf("/n  for_each test ffunc_int_int:/n");
  std::for_each(for_each_test.begin(), for_each_test.end(), ffunc_int_int);
  printf("/n  for_each test ffunc_int_int1:/n");
  std::for_each(for_each_test.begin(), for_each_test.end(), ffunc_int_int1);

  delegate<delegate<functor1<int> > > delegate_for_delegate_test(ffunc__int1);
  delegate_for_delegate_test += ffunc__int1;
  printf("/n  delegate_for_delegate_test 1:/n");
  std::for_each(for_each_test.begin(), for_each_test.end(), 
    delegate_for_delegate_test);
  ffunc__int1 -= make_functor(testfunc__int);
  delegate_for_delegate_test += ffunc__int1;
  printf("/n  delegate_for_delegate_test 2:/n");
  std::for_each(for_each_test.begin(), for_each_test.end(), 
    delegate_for_delegate_test);

  return 0;
}
coolcch
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++实现C#事件机制
11-22
C++ 模拟 C# 事件 函数指针 尾随参数
用 C++ 实现 C# 中的 委托/事件 (2-delegate event functor)
coolcch的专栏
03-21 1261
前两天看程序员杂志看到关于 C# 中的委托/事件觉得用起来好像是挺方便的本人热衷于 C++想想用 C++ 来模拟似乎也可以于是就有了下面的代码...(VC6 不支持偏特化 本人工作环境就是 VC6 痛啊~~~)没有返回值的函数用 delegate否则就用 delegate_rtfunctor 也一样 functorN/functorN_rtdelegate 的模板参数可以是函数指针(非成员函数
用C++实现C#中的委托/事件(标准C++之升级版)
coolcch的专栏
03-25 1096
看到csdn上前辈高人写的文章http://www.csdn.net/Develop/Read_Article.asp?Id=13147觉得用 VC6 来写这个确实有点束手束脚我把他的代码拿来改造了一下 于是就有了这个升级版这次可真的是完美模拟了 :)在 GCC 下编译运行通过VC7 应该也没问题吧(代码五颜六色的太大了 一篇文档放不下 这次就不弄了自己粘到C++的编辑器里去看吧！)2004.
用C++实现C#中的委托和事件
双脚踏实地
11-25 1830
 C#中的测试代码：using System;namespace testEventApp{ public delegate void ClassSender_Event_Handler(object sender, string strEventArg); /// /// ClassReceiver 的摘要说明。 /// class ClassR
C++如何实现C#的事件机制
weixin_30555515的博客
03-04 128
C++实现事件机制主要靠类的继承重写虚函数，映像比较深的MFC,以On开头的函数。 这样如果要实现类B监听类A的机制，就必须用类B继承类A，这种强制的继承让人很不爽。 C#的事件机制就比较好，类A发布事件，任何类都可以订阅，且没有强制的继承关系。 C++典型的重写虚函数事件机制： 1 //----------------------------------------------...
yaml-cpp-yaml-cpp-0.6.2.zip
12-04
《深入理解YAML-CPP库：解析YAML文件的CPP实现》 YAML，全称“YAML Ain't Markup Language”（发音同“camel”，意为“不是标记语言”），是一种简洁、直观的数据序列化语言。它常用于配置文件、数据交换格式等领域...
protobuf-cpp-3.1.0.tar.gz（下载附件zip文件解压后便是需要的文件）
03-19
Ubuntu18.04+OpenCV3.2.0源码安装时，出现错误：Failed to download v3.1.0/protobuf-cpp-3.1.0.tar.gz ，解决方法：下载附件zip文件，解压后得到protobuf-cpp-3.1.0.tar.gz文件，替换/opencv_contrib-3.2.0/modules...
yaml-cpp-yaml-cpp-0.6.0.tar.gz
03-15
- 自动化测试：在测试框架中，可以用yaml-cpp加载测试用例，实现灵活的参数化测试。 总之，yaml-cpp库是运维工作中处理YAML数据的强大工具，它提供了方便的API，使得C++开发者能够轻松地与YAML格式交互，提高运维...
cppcheck-2.0.zip
05-23
Cppcheck is a static analysis tool for C/C++ code. It provides unique code analysis to detect bugs and focuses on detecting undefined behaviour and dangerous coding constructs. The goal is to have ...
期末C++----1.cpp
06-13
期末C++----1.cpp
C++封装C#中的事件
04-28
C++封装C#中的事件
c#委托事件的实现
01-09
基于c#程序对c语言中的委托事件进行详细的分析与讲解
c++实现委托和事件
11-23
使用c++的function和bind实现c#中的委托和事件
用C++模拟C#事件机制
11-24 955
    C#中的事件机制可以很方便的实现设计模式中的Observer模式，C#提供了delegate 和 event 来实现这种机制，实际上只要delagate就可以实现event效果，event语法完全没必要，因为delegate是多播的。本文提供了一个C++版本的实现，与C#原生的事件机制相比，只有一点不同，我实现的delegate是单播的（为了避免delegate 和 event 功能重复的
c++实现类似c#的事件,依赖Poco库
hk595
12-31 197
#include “Poco/BasicEvent.h” #include “Poco/Delegate.h” #include using Poco::BasicEvent; using Poco::delegate; class Source { public: BasicEvent theEvent; void fireEvent(int n) { theEvent(this, n); } }; class Target { public: void onEvent(const void*
C++ 模拟 C#事件
sudazf的专栏
06-08 641
网上看到一些关于C++模拟和C#类似的Event处理，这里记录一下：新建一个event.h头文件：#pragma once template &lt;typename Handler&gt; class event { private: Handler m_Handler; protected: //模拟C# event 的add/remove访问器 //如果要重新实现add/remo...
c++实现类似c#事件机制的链接
智周万物
10-29 810
<br />http://www.codeproject.com/KB/cpp/CppEvents.aspx<br />http://www.codeproject.com/KB/cpp/accppdelegates.aspx<br />http://www.codeproject.com/KB/architecture/observer_with_templates.aspx
C++模拟C#事件委托机制（二）
weixin_30673715的博客
06-26 99
原文 来自于http://www.cnblogs.com/netssfy/archive/2010/02/02/1662056.html 为了解决非法地址访问的冲突，首先需要知道发生该错误的原因是什么 事件与委托的关系是1对多的，事件与委托对象实例的关系是多对多的，所以使用CListenerAgent将这种多对多的关系拆开。而每个CListenerAgent是事件与委托对象实例的一一对应 ...
c++实现c#委托机制
SunminpSun的专栏
11-13 760
看了两本关于设计模式的书，一本是用的java语言描写的《设计模式之禅》，另一本是用C#语言描述的《大话设计模式》，两本都不是我常用的C/C++，不过C++是面向对象的语言，当然你也可以用它编写面向过程的程序。        既然C++是面向对象的语言，那么所有的两本书讲的所有的设计模式都应该能够实现，只是实现的具体方法不一样而已，比如一个单例模式，用java实现的方法如下：     class
E:\android\SDK\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\bin\clang++.exe --target=aarch64-none-linux-android21 --sysroot=E:/android/SDK/ndk/25.1.8937393/toolchains/llvm/prebuilt/windows-x86_64/sysroot -Dprac071301_EXPORTS -g -DANDROID -fdata-sections -ffunction-sections -funwind-tables -fstack-protector-strong -no-canonical-prefixes -D_FORTIFY_SOURCE=2 -Wformat -Werror=format-security -std=c++11 -fno-limit-debug-info -fPIC -MD -MT CMakeFiles/prac071301.dir/native-lib.cpp.o -MF CMakeFiles\prac071301.dir\native-lib.cpp.o.d -o CMakeFiles/prac071301.dir/native-lib.cpp.o -c "F:/android studio project/prac071301/app/src/main/cpp/native-lib.cpp" F:/android studio project/prac071301/app/src/main/cpp/native-lib.cpp:28:31: error: too few arguments to function call, expected 2, have 1 env->NewString("���Ϻ�"); ~~~~~~~~~~~~~~ ^ E:/android/SDK/ndk/25.1.8937393/toolchains/llvm/prebuilt/windows-x86_64/sysroot/usr/include/jni.h:827:13: note: 'NewString' declared here jstring NewString(const jchar* unicodeChars, jsize len) ^
最新发布
07-15
这个错误提示是因为`NewString`函数需要两个参数，但是你只传递了一个参数。正确的调用方式应该是`env->NewString(unicodeChars, len)`，其中`unicodeChars`是一个`jchar`类型的数组，`len`是数组的长度。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值