用C++实现C#中的委托/事件(标准C++之升级版)

看到csdn上前辈高人写的文章
http://www.csdn.net/Develop/Read_Article.asp?Id=13147
觉得用 VC6 来写这个确实有点束手束脚
我把他的代码拿来改造了一下 于是就有了这个升级版
这次可真的是完美模拟了 :)
在 GCC 下编译运行通过
VC7 应该也没问题吧
(代码五颜六色的太大了 一篇文档放不下 这次就不弄了
自己粘到C++的编辑器里去看吧！)

2004.3.24 代码修改
内容：修改 template <typename T> class delegate
使之能够用于一般的函数对象 如 std::mem_fun_t, std::mem_fun_ref_t
注：用于函数对象时 只支持 Multi-cast delegates

//filename: funtraits.h #ifndef _FUNTRAITS_H_ #define _FUNTRAITS_H_ // 函数traits,用来提取函数的返回类型 template<class T> struct function_traits { }; template<class RT> struct function_traits< RT(*)() > { typedef RT(*function_type)(); typedef RT result_type; }; template<class RT,class AT> struct function_traits< RT(*)(AT) > { typedef RT(*function_type)(AT); typedef RT result_type; typedef AT argument_type; }; template<class RT,class AT1,class AT2> struct function_traits< RT(*)(AT1,AT2) > { typedef RT(*function_type)(AT1,AT2); typedef RT result_type; typedef AT1 first_argument_type; typedef AT2 second_argument_type; }; template<class RT,class AT1,class AT2,class AT3> struct function_traits< RT(*)(AT1,AT2,AT3) > { typedef RT(*function_type)(AT1,AT2,AT3); typedef RT result_type; typedef AT1 first_argument_type; typedef AT2 second_argument_type; typedef AT3 third_argument_type; }; // 函数traits,用来提取类成员函数的返回类型 template<class RT, class OT> struct function_traits< RT (OT::*)() > { typedef RT(*function_type)(); typedef OT object_type; typedef RT result_type; }; template<class RT, class OT, class AT> struct function_traits< RT (OT::*)(AT) > { typedef RT(*function_type)(AT); typedef OT object_type; typedef RT result_type; typedef AT argument_type; typedef AT first_argument_type; }; template<class RT,class OT,class AT1,class AT2> struct function_traits< RT (OT::*)(AT1,AT2) > { typedef RT(*function_type)(AT1,AT2); typedef OT object_type; typedef RT result_type; typedef AT1 first_argument_type; typedef AT2 second_argument_type; }; template<class RT,class OT,class AT1,class AT2,class AT3> struct function_traits< RT (OT::*)(AT1,AT2,AT3) > { typedef RT(*function_type)(AT1,AT2,AT3); typedef OT object_type; typedef RT result_type; typedef AT1 first_argument_type; typedef AT2 second_argument_type; typedef AT3 third_argument_type; }; template<class RT, class OT> struct function_traits< RT (OT::*)() const > { typedef RT(*function_type)(); typedef OT object_type; typedef RT result_type; }; template<class RT, class OT, class AT> struct function_traits< RT (OT::*)(AT) const > { typedef RT(*function_type)(AT); typedef OT object_type; typedef RT result_type; typedef AT argument_type; typedef AT first_argument_type; }; template<class RT,class OT,class AT1,class AT2> struct function_traits< RT (OT::*)(AT1,AT2) const > { typedef RT(*function_type)(AT1,AT2); typedef OT object_type; typedef RT result_type; typedef AT1 first_argument_type; typedef AT2 second_argument_type; }; template<class RT,class OT,class AT1,class AT2,class AT3> struct function_traits< RT (OT::*)(AT1,AT2,AT3) const > { typedef RT(*function_type)(AT1,AT2,AT3); typedef OT object_type; typedef RT result_type; typedef AT1 first_argument_type; typedef AT2 second_argument_type; typedef AT3 third_argument_type; }; // 把一个普通函数类向转化为类型兼容的指定类的成员函数类型 template <typename OT, typename PFT> struct to_member_function_pointer { }; template <typename OT,typename RT> struct to_member_function_pointer< OT, RT(*)() > { typedef RT (OT::*type)(); }; template <typename OT, typename RT, typename AT> struct to_member_function_pointer< OT, RT(*)(AT) > { typedef RT (OT::*type)(AT); }; template <typename OT, typename RT, typename AT1, typename AT2> struct to_member_function_pointer< OT, RT(*)(AT1,AT2) > { typedef RT (OT::*type)(AT1,AT2); }; template <typename OT, typename RT, typename AT1, typename AT2, typename AT3> struct to_member_function_pointer< OT, RT(*)(AT1,AT2,AT3) > { typedef RT (OT::*type)(AT1,AT2,AT3); }; // 转化为const 成员函数 template <typename OT, typename PFT> struct to_const_member_function_pointer { }; template <typename OT, typename RT> struct to_const_member_function_pointer< OT, RT(*)() > { typedef RT (OT::*type)() const; }; template <typename OT, typename RT, typename AT> struct to_const_member_function_pointer< OT, RT(*)(AT) > { typedef RT (OT::*type)(AT) const; }; template <typename OT, typename RT, typename AT1, typename AT2> struct to_const_member_function_pointer< OT, RT(*)(AT1,AT2) > { typedef RT (OT::*type)(AT1,AT2) const; }; template <typename OT, typename RT, typename AT1, typename AT2, typename AT3> struct to_const_member_function_pointer< OT, RT(*)(AT1,AT2,AT3) > { typedef RT (OT::*type)(AT1,AT2,AT3) const; }; #endif // #ifndef _FUNTRAITS_H_

//filename: delegate.h #ifndef _DELEGATE_H_ #define _DELEGATE_H_ #include <vector> #include <algorithm> #include <stdexcept> #include "funtraits.h" #define DELEGATE_DEFINE \ protected: \ typedef typename base_class::deleobject \ deleobject; \ typedef typename base_class::object_member_function_pointer \ object_member_function_pointer; \ typedef typename base_class::const_object_member_function_pointer \ const_object_member_function_pointer; \ typedef typename base_class::result_type \ result_type; \ typedef typename base_class::function_union \ function_union; #define DELEGATE_COMMON \ public: \ delegate() {} \ delegate(function_pointer pf) : base_class(pf) {} \ template<typename O> \ delegate(const O *pObject, \ typename to_member_function_pointer<O, function_pointer>::type pmf) : \ base_class(pObject, pmf) {} \ template<typename O> \ delegate(const O *pObject, \ typename to_const_member_function_pointer<O, function_pointer>::type pmf) : \ base_class(pObject, pmf) {} \ delegate(const delegate& rhs) : \ base_class(rhs) {} \ delegate &operator =(function_pointer pf) \ { \ base_class::operator =(pf); \ return *this; \ } \ delegate &operator =(const base_class& rhs) \ { \ base_class::operator =(rhs); \ return *this; \ } #define DELEGATE_OPERATOR_BRACKET \ public: \ void operator()() const \ { \ typename std::vector<function_union>::const_iterator i = funcs.begin(); \ for (; i != funcs.end(); ++i) \ { \ if (i->m_pObject == NULL) \ (*i->m_pf)(); \ else \ (i->m_pObject->*(i->m_pmf))(); \ } \ } \ template <typename P1> \ void operator()(P1 p1) const \ { \ typename std::vector<function_union>::const_iterator i = funcs.begin(); \ for (; i != funcs.end(); ++i) \ { \ if (i->m_pObject == NULL) \ (*i->m_pf)(p1); \ else \ (i->m_pObject->*(i->m_pmf))(p1); \ } \ } \ template <typename P1, typename P2> \ void operator()(P1 p1, P2 p2) const \ { \ typename std::vector<function_union>::const_iterator i = funcs.begin(); \ for (; i != funcs.end(); ++i) \ { \ if (i->m_pObject == NULL) \ (*i->m_pf)(p1, p2); \ else \ (i->m_pObject->*(i->m_pmf))(p1, p2); \ } \ } \ template <typename P1, typename P2, typename P3> \ void operator()(P1 p1, P2 p2, P3 p3) const \ { \ typename std::vector<function_union>::const_iterator i = funcs.begin(); \ for (; i != funcs.end(); ++i) \ { \ if (i->m_pObject == NULL) \ (*i->m_pf)(p1, p2, p3); \ else \ (i->m_pObject->*(i->m_pmf))(p1, p2, p3); \ } \ } #define DELEGATE_OPERATOR_BRACKET_RT \ public: \ result_type operator()() const \ { \ if (funcs.size() != 1) \ throw std::runtime_error("non-multicast delegate: method error!"); \ if (funcs.front().m_pObject == NULL) \ return (*funcs.front().m_pf)(); \ return (funcs.front().m_pObject->*(funcs.front().m_pmf))(); \ } \ template <typename P1> \ result_type operator()(P1 p1) const \ { \ if (funcs.size() != 1) \ throw std::runtime_error("non-multicast delegate: method error!"); \ if (funcs.front().m_pObject == NULL) \ return (*funcs.front().m_pf)(p1); \ return (funcs.front().m_pObject->*(funcs.front().m_pmf))(p1); \ } \ template <typename P1, typename P2> \ result_type operator()(P1 p1, P2 p2) const \ { \ if (funcs.size() != 1) \ throw std::runtime_error("non-multicast delegate: method error!"); \ if (funcs.front().m_pObject == NULL) \ return (*funcs.front().m_pf)(p1, p2); \ return (funcs.front().m_pObject->*(funcs.front().m_pmf))(p1, p2); \ } \ template <typename P1, typename P2, typename P3> \ result_type operator()(P1 p1, P2 p2, P3 p3) const \ { \ if (funcs.size() != 1) \ throw std::runtime_error("non-multicast delegate: method error!"); \ if (funcs.front().m_pObject == NULL) \ return (*funcs.front().m_pf)(p1, p2, p3); \ return (funcs.front().m_pObject->*(funcs.front().m_pmf))(p1, p2, p3); \ } template <typename T> class delegate { protected: typedef T functor; std::vector<functor> funcs; public: delegate() {} delegate(const functor& Func) { // if (!(Func == NULL))

funcs.push_back(Func); } delegate(const delegate& rhs) : funcs(rhs.funcs) {} void operator ()() const { typename std::vector<functor>::const_iterator i = funcs.begin(); for (; i != funcs.end(); ++i) { (*i)(); } } template <typename P1> void operator ()(P1 p1) const { typename std::vector<functor>::const_iterator i = funcs.begin(); for (; i != funcs.end(); ++i) { (*i)(p1); } } template <typename P1, typename P2> void operator ()(P1 p1, P2 p2) const { typename std::vector<functor>::const_iterator i = funcs.begin(); for (; i != funcs.end(); ++i) { (*i)(p1, p2); } } template <typename P1, typename P2, typename P3> void operator ()(P1 p1, P2 p2, P3 p3) const { typename std::vector<functor>::const_iterator i = funcs.begin(); for (; i != funcs.end(); ++i) { (*i)(p1, p2, p3); } } bool operator ==(const delegate& rhs) const { return funcs == rhs.funcs; } /* bool operator ==(const void* rhs) const { if (funcs.size()) return &funcs == rhs; return NULL == rhs; }*/ delegate& operator =(const delegate& rhs) { funcs = rhs.funcs; return *this; } delegate& operator +=(const delegate& rhs) { if (this == &rhs) return *this; typename std::vector<functor>::const_iterator j, i = rhs.funcs.begin(); for (; i != rhs.funcs.end(); ++i) { j = std::find(funcs.begin(), funcs.end(), *i); if (j == funcs.end()) funcs.push_back(*i); } return *this; } delegate& operator -=(const delegate& rhs) { if (this == &rhs) { funcs.clear(); return *this; } typename std::vector<functor>::iterator j; typename std::vector<functor>::const_iterator i = rhs.funcs.begin(); for (; i != rhs.funcs.end(); ++i) { j = std::find(funcs.begin(), funcs.end(), *i); if (j != funcs.end()) funcs.erase(j); } return *this; } delegate operator +(const delegate& rhs) const { return delegate(*this) += rhs; } delegate operator -(const delegate& rhs) const { return delegate(*this) -= rhs; } delegate& operator =(const functor& rhs) { funcs.clear(); // if (!(rhs == NULL)) funcs.push_back(rhs); return *this; } delegate& operator +=(const functor& rhs) { // if (rhs == NULL) // return *this; typename std::vector<functor>::const_iterator j = std::find(funcs.begin(), funcs.end(), rhs); if (j == funcs.end()) funcs.push_back(rhs); return *this; } delegate& operator -=(const functor& rhs) { // if (rhs == NULL) // return *this; typename std::vector<functor>::iterator j = std::find(funcs.begin(), funcs.end(), rhs); if (j != funcs.end()) funcs.erase(j); return *this; } delegate operator +(const functor& rhs) const { return delegate(*this) += rhs; } delegate operator -(const functor& rhs) const { return delegate(*this) -= rhs; } friend delegate operator +(const functor& lhs, const delegate& rhs) { return rhs + lhs; } }; template <typename T> class delegate_base { protected: class deleobject {}; typedef T function_pointer; typedef typename to_member_function_pointer<deleobject, function_pointer>::type object_member_function_pointer; typedef typename to_const_member_function_pointer<deleobject, function_pointer>::type const_object_member_function_pointer; typedef typename function_traits<function_pointer>::result_type result_type; struct function_union { union { function_pointer m_pf; object_member_function_pointer m_pmf; const_object_member_function_pointer m_pcmf; }; union { deleobject *m_pObject; const deleobject *m_pcObject; }; function_union() : m_pf(NULL), m_pObject(NULL) {} function_union(function_pointer pf) : m_pf(pf), m_pObject(NULL) {} template <class O> function_union(const O* pObject, typename to_member_function_pointer<O, function_pointer>::type pmf) : m_pmf(*reinterpret_cast<object_member_function_pointer*>(&pmf)), m_pcObject(reinterpret_cast<const deleobject*>(pObject)) {} template <class O> function_union(const O* pObject, typename to_const_member_function_pointer<O, function_pointer>::type pmf) : m_pcmf(*reinterpret_cast<const_object_member_function_pointer*>(&pmf)), m_pcObject(reinterpret_cast<const deleobject*>(pObject)) {} bool operator ==(const function_union& rhs) const { if (m_pObject == NULL) return rhs.m_pObject == NULL && m_pf == rhs.m_pf; return m_pObject == rhs.m_pObject && m_pmf == rhs.m_pmf; } bool operator ==(function_pointer rhs) const { return m_pObject == NULL && m_pf == rhs; } bool operator ==(const void* rhs) const { return m_pObject == NULL && m_pf == rhs; } }; std::vector<function_union> funcs; public: delegate_base() {} delegate_base(function_pointer pf) { if (!(pf == NULL)) funcs.push_back(pf); } template<typename O> delegate_base(const O *pObject, typename to_member_function_pointer<O, function_pointer>::type pmf) { if (pObject && pmf) funcs.push_back(function_union(pObject, pmf)); } template<typename O> delegate_base(const O *pObject, typename to_const_member_function_pointer<O, function_pointer>::type pmf) { if (pObject && pmf) funcs.push_back(function_union(pObject, pmf)); } delegate_base(const delegate_base& rhs) : funcs(rhs.funcs) {} bool operator ==(const void* rhs) const { if (funcs.size()) return &funcs == rhs; return NULL == rhs; } bool operator ==(const delegate_base& rhs) const { return funcs == rhs.funcs; } bool operator !=(const delegate_base& rhs) const { return funcs != rhs.funcs; } delegate_base &operator =(const delegate_base& rhs) { funcs = rhs.funcs; return *this; } delegate_base &operator +=(const delegate_base& rhs) { if (this == &rhs) return *this; typename std::vector<function_union>::const_iterator j, i = rhs.funcs.begin(); for (; i != rhs.funcs.end(); ++i) { j = std::find(funcs.begin(), funcs.end(), *i); if (j == funcs.end()) funcs.push_back(*i); } return *this; } delegate_base& operator -=(const delegate_base& rhs) { if (this == &rhs) { funcs.clear(); return *this; } typename std::vector<function_union>::iterator j; typename std::vector<function_union>::const_iterator i = rhs.funcs.begin(); for (; i != rhs.funcs.end(); ++i) { j = std::find(funcs.begin(), funcs.end(), *i); if (j != funcs.end()) funcs.erase(j); } return *this; } delegate_base operator +(const delegate_base& rhs) const { return delegate_base(*this) += rhs; } delegate_base operator -(const delegate_base& rhs) const { return delegate_base(*this) -= rhs; } delegate_base &operator =(function_pointer pf) { funcs.clear(); if (!(pf == NULL)) funcs.push_back(pf); return *this; } delegate_base& operator +=(function_pointer rhs) { if (rhs == NULL) return *this; typename std::vector<function_union>::const_iterator j = std::find(funcs.begin(), funcs.end(), rhs); if (j == funcs.end()) funcs.push_back(rhs); return *this; } delegate_base& operator -=(function_pointer rhs) { if (rhs == NULL) return *this; typename std::vector<function_union>::iterator j = std::find(funcs.begin(), funcs.end(), rhs); if (j != funcs.end()) funcs.erase(j); return *this; } delegate_base operator +(function_pointer rhs) const { return delegate_base(*this) += rhs; } delegate_base operator -(function_pointer rhs) const { return delegate_base(*this) -= rhs; } friend delegate_base operator +(function_pointer lhs, const delegate_base& rhs) { return rhs + lhs; } }; template <typename R> class delegate<R (*)()> : public delegate_base<R (*)()> { protected: typedef delegate_base<R (*)()> base_class; typedef R (*function_pointer)(); DELEGATE_DEFINE DELEGATE_COMMON DELEGATE_OPERATOR_BRACKET_RT }; template <typename R, typename V1> class delegate<R (*)(V1)> : public delegate_base<R (*)(V1)> { protected: typedef delegate_base<R (*)(V1)> base_class; typedef R (*function_pointer)(V1); DELEGATE_DEFINE DELEGATE_COMMON DELEGATE_OPERATOR_BRACKET_RT }; template <typename R, typename V1, typename V2> class delegate<R (*)(V1, V2)> : public delegate_base<R (*)(V1, V2)> { protected: typedef delegate_base<R (*)(V1, V2)> base_class; typedef R (*function_pointer)(V1, V2); DELEGATE_DEFINE DELEGATE_COMMON DELEGATE_OPERATOR_BRACKET_RT }; template <> class delegate<void (*)()> : public delegate_base<void (*)()> { protected: typedef delegate_base<void (*)()> base_class; typedef void (*function_pointer)(); protected: typedef base_class::deleobject deleobject; typedef base_class::object_member_function_pointer object_member_function_pointer; typedef base_class::const_object_member_function_pointer const_object_member_function_pointer; typedef base_class::result_type result_type; typedef base_class::function_union function_union; DELEGATE_COMMON public: void operator()() const { std::vector<function_union>::const_iterator i = funcs.begin(); for (; i != funcs.end(); ++i) { if (i->m_pObject == NULL) (*i->m_pf)(); else (i->m_pObject->*(i->m_pmf))(); } } }; template <typename V1> class delegate<void (*)(V1)> : public delegate_base<void (*)(V1)> { protected: typedef delegate_base<void (*)(V1)> base_class; typedef void (*function_pointer)(V1); DELEGATE_DEFINE DELEGATE_COMMON DELEGATE_OPERATOR_BRACKET }; template <typename V1, typename V2> class delegate<void (*)(V1, V2)> : public delegate_base<void (*)(V1, V2)> { protected: typedef delegate_base<void (*)(V1, V2)> base_class; typedef void (*function_pointer)(V1, V2); DELEGATE_DEFINE DELEGATE_COMMON DELEGATE_OPERATOR_BRACKET }; template <typename V1, typename V2, typename V3> class delegate<void (*)(V1, V2, V3)> : public delegate_base<void (*)(V1, V2, V3)> { protected: typedef delegate_base<void (*)(V1, V2, V3)> base_class; typedef void (*function_pointer)(V1, V2, V3); DELEGATE_DEFINE DELEGATE_COMMON DELEGATE_OPERATOR_BRACKET }; template <typename F> inline delegate<F> make_delegate(F& fp) { return delegate<F>(fp); } template <typename F> inline delegate<F*> make_delegate(F* fp) { return delegate<F*>(fp); } template <typename F> inline delegate<F> make_delegate(const F& fp) { return delegate<F>(fp); } template <typename F> inline delegate<F*> make_delegate(const F* fp) { return delegate<F*>(fp); } template <class T, typename F> inline delegate<typename function_traits<F>::function_type> make_delegate(const T* tp, F fp) { return delegate<typename function_traits<F>::function_type>(tp, fp); } #endif // #ifndef _DELEGATE_H_

//filename: event.h #ifndef _EVENT_H_ #define _EVENT_H_ typedef void* object; class EventArgs { public: bool cancel; EventArgs() : cancel(false) {} }; template <typename T> class event { T handlers; public: void operator +=(const T& rhs) { handlers += rhs; } void operator -=(const T& rhs) { handlers -= rhs; } void operator()() const { handlers(NULL, EventArgs()); } template <typename P1> void operator()(P1 p1) const { handlers(p1, EventArgs()); } template <typename P1, typename P2> void operator()(P1 p1, P2 p2) const { handlers(p1, p2); } }; #endif // #ifndef _EVENT_H_

//filename: main.cpp #include <stdlib.h> #include "delegate.h" #include "event.h" #include <functional> #define make_functor make_delegate #define make_functor_rt make_delegate class MyEventArgs : public EventArgs { public: MyEventArgs(const char* Context = "") : context(Context) {} const char* context; }; typedef delegate<void (*)(object, MyEventArgs&)> EventHandler1; typedef EventHandler1 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(this, &Master_base::Process_OkClick); pro.OkClick2 += EventHandler2(&Master_base::static_Process_OkClick); pro.OkClick2 += EventHandler2(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(this, &Master_derived::Process_OkClick_Myself); pro.OkClick2 -= EventHandler2((Master_base*)this, (void (Master_base::*)(object, MyEventArgs&))&Master_derived::Process_OkClick); pro.OkClick2 -= EventHandler2(this, &Master_derived::Process_OkClick_Myself1); pro.OkClick2 += EventHandler2(&Master_derived::static_Process_OkClick_Myself); pro.OkClick2 -= EventHandler2(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(int argc, char *argv[]) { 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<func__> ffunc__1(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<func__int> ffunc__int1(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<func__int_str> ffunc__int_str1(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<func_int_> ffunc_int_(testfunc_int_); printf("ffunc_int_()=%d\n", ffunc_int_()); printf(" functor.func_int_:\n"); delegate<func_int_> ffunc_int_1(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<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<func_int_int> ffunc_int_int1(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<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<func_int_int_str> ffunc_int_int_str1(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<func__> ftest_virtual; ftest_virtual = delegate<func__>(ffunc__1) + delegate<func__>(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(&global_Process_OkClick); teststatic1((object)NULL, MyEventArgs()); MyEventArgs e; delegate<void (*)(object, MyEventArgs&)> teststatic2(&global_Process_OkClick); teststatic2((object)NULL, e); make_functor(&global_Process_OkClick)((object)NULL, e); printf("\n Test make_functor static member:\n"); EventHandler2 teststatic3(&Master_base::static_Process_OkClick); teststatic3((object)NULL, MyEventArgs()); delegate<void (*)(object, MyEventArgs&)> teststatic4(&Master_base::static_Process_OkClick); teststatic4((object)NULL, e); make_functor(&Master_base::static_Process_OkClick)((object)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<func__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); system("PAUSE"); return 0; }

本文地址：http://com.8s8s.com/it/it28934.htm