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

前两天看程序员杂志
看到关于 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;
}