看到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;
}
