c++ 的 delegate/event 实现，欢迎大家讨论！

[coolcch]

#include <stdio.h>

#include "delegate.h"
#include "event.h"
#include "functor.h"


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));
}
private: void Process_OkClick(object source, MyEventArgs& e)
{
printf(" Process_OkClick, \t%s\n", e.context);
}
private: static void static_Process_OkClick(object source, MyEventArgs& e)
{
printf("static_Process_OkClick, \t%s\n", e.context);
}
public: virtual void test_virtual()
{
printf("Master_base::test_virtual\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_derived*)NULL, &Master_derived::Process_OkClick_Myself)); //NULL!!!
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));
}
private: 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);
}
private: 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()
{
printf("Master_derived::test_virtual\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__ = 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("\n test_virtual1:\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();

return 0;
}

[coolcch]

//delegate.h
#ifndef _DELEGATE_H_
#define _DELEGATE_H_

#include <vector>
#include <algorithm>
#include "delegate_rt.h"

template <typename T>
class delegate
{
protected:
std::vector<T> funcs;
public:
typedef T FunctorType;

delegate() {}
explicit delegate(T Func) : funcs(1, Func) { if (!Func) funcs.clear(); }
delegate(const delegate& rhs) : funcs(rhs.funcs) {}

void operator()()
{
for (std::vector<T>::iterator i = funcs.begin(); i != funcs.end(); ++i)
{
(*i)();
}
}
template <typename P1>
void operator()(P1 p1)
{
for (std::vector<T>::iterator i = funcs.begin(); i != funcs.end(); ++i)
{
(*i)(p1);
}
}
template <typename P1, typename P2>
void operator()(P1 p1, P2 p2)
{
for (std::vector<T>::iterator i = funcs.begin(); i != funcs.end(); ++i)
{
(*i)(p1, p2);
}
}

delegate& operator =(const delegate& rhs)
{
funcs = rhs.funcs;
return *this;
}
delegate& operator +=(const delegate& rhs)
{
// funcs.insert(funcs.end(), rhs.funcs.begin(), rhs.funcs.end());
std::vector<T>::iterator j;
for (std::vector<T>::const_iterator i = rhs.funcs.begin(); 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)
{
std::vector<T>::iterator j;
for (std::vector<T>::const_iterator i = rhs.funcs.begin(); 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 =(T rhs)
{
funcs.resize(1);
funcs.front() = rhs;
return *this;
}
delegate& operator +=(T rhs)
{
// funcs.puch_back(rhs);
std::vector<T>::iterator j = std::find(funcs.begin(), funcs.end(), rhs);
if (j == funcs.end())
funcs.push_back(rhs);
return *this;
}
delegate& operator -=(T rhs)
{
std::vector<T>::iterator j = std::find(funcs.begin(), funcs.end(), rhs);
if (j != funcs.end())
funcs.erase(j);
return *this;
}
delegate operator +(T rhs) const
{
return delegate(*this) += rhs;
}
delegate operator -(T rhs) const
{
return delegate(*this) -= rhs;
}
friend delegate operator +(T lhs, const delegate& rhs)
{
return rhs + lhs;
}
};

#endif // #ifndef _DELEGATE_H_

[coolcch]

//delegate_rt.h
#ifndef _DELEGATE_RT_H_
#define _DELEGATE_RT_H_

#include <vector>
#include <algorithm>

template <typename R, typename T>
class delegate_rt
{
protected:
std::vector<T> funcs;
public:
typedef T FunctorType;
typedef R ReturnType;

delegate_rt() {}
explicit delegate_rt(T Func) : funcs(1, Func) { if (!Func) funcs.clear(); }
delegate_rt(const delegate_rt& rhs) : funcs(rhs.funcs) {}

ReturnType operator()()
{
if (funcs.size() != 1)
throw std::runtime_error("non-multicast delegate: method error!");
return funcs.front()();
for (std::vector<T>::iterator i = funcs.begin(); i != funcs.end(); ++i)
{
(*i)();
}
}
template <typename P1>
ReturnType operator()(P1 p1)
{
if (funcs.size() != 1)
throw std::runtime_error("non-multicast delegate: method error!");
return funcs.front()(p1);
for (std::vector<T>::iterator i = funcs.begin(); i != funcs.end(); ++i)
{
(*i)(p1);
}
}
template <typename P1, typename P2>
ReturnType operator()(P1 p1, P2 p2)
{
if (funcs.size() != 1)
throw std::runtime_error("non-multicast delegate: method error!");
return funcs.front()(p1, p2);
for (std::vector<T>::iterator i = funcs.begin(); i != funcs.end(); ++i)
{
(*i)(p1, p2);
}
}

delegate_rt& operator =(const delegate_rt& rhs)
{
funcs = rhs.funcs;
return *this;
}
delegate_rt& operator +=(const delegate_rt& rhs)
{
// funcs.insert(funcs.end(), rhs.funcs.begin(), rhs.funcs.end());
std::vector<T>::iterator j;
for (std::vector<T>::const_iterator i = rhs.funcs.begin(); i != rhs.funcs.end(); ++i)
{
j = std::find(funcs.begin(), funcs.end(), *i);
if (j == funcs.end())
funcs.push_back(*i);
}
return *this;
}
delegate_rt& operator -=(const delegate_rt& rhs)
{
std::vector<T>::iterator j;
for (std::vector<T>::const_iterator i = rhs.funcs.begin(); i != rhs.funcs.end(); ++i)
{
j = std::find(funcs.begin(), funcs.end(), *i);
if (j != funcs.end())
funcs.erase(j);
}
return *this;
}
delegate_rt operator +(const delegate_rt& rhs) const
{
return delegate_rt(*this) += rhs;
}
delegate_rt operator -(const delegate_rt& rhs) const
{
return delegate_rt(*this) -= rhs;
}

delegate_rt& operator =(T rhs)
{
funcs.resize(1);
funcs.front() = rhs;
return *this;
}
delegate_rt& operator +=(T rhs)
{
// funcs.puch_back(rhs);
std::vector<T>::iterator j = std::find(funcs.begin(), funcs.end(), rhs);
if (j == funcs.end())
funcs.push_back(rhs);
return *this;
}
delegate_rt& operator -=(T rhs)
{
std::vector<T>::iterator j = std::find(funcs.begin(), funcs.end(), rhs);
if (j != funcs.end())
funcs.erase(j);
return *this;
}
delegate_rt operator +(T rhs) const
{
return delegate_rt(*this) += rhs;
}
delegate_rt operator -(T rhs) const
{
return delegate_rt(*this) -= rhs;
}
friend delegate_rt operator +(T lhs, const delegate_rt& rhs)
{
return rhs + lhs;
}
};

#endif // #ifndef _DELEGATE_RT_H_

[coolcch]

//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;
}
template <typename P1>
void operator()(P1 p1)
{
handlers(p1, EventArgs());
}
template <typename P1, typename P2>
void operator()(P1 p1, P2 p2)
{
handlers(p1, p2);
}
};

#endif // #ifndef _EVENT_H_