用 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;
}
