delegate.h

这是本人在工作中积累的VC++类库

/************************************************************************
模快名:		moxu 公共类库
功能:		实现面向对象的事件回调
完成日期:	2007-10-20
作者:		许 培 Xu Pei(Email/MSN: [e-mail])

本代码可以自由使用，但因使用本代码造成的后果，本人不承担任何责任
************************************************************************/

#pragma once

namespace moxu
{

//////////////////////////////////////////////////////////////////////////
//delegate0
template<typename R>
class Delegate0
{
public:
	virtual ~Delegate0(void){ }
	virtual R operator()(void) = 0;
};
template<typename C, typename R>
class Delegate0Impl : public Delegate0<R>
{
private:
	typedef R (C::*F)(void);
	C* m_class;
	F m_fun;
public:
	Delegate0Impl(C* c, F f){ m_class = c; m_fun = f; }
	virtual R operator()(void)
	{
		if(m_class)
			return (m_class->*m_fun)();
	}
};
template<typename C, typename R>
Delegate0<R>* MakeDelegate(C* c, R (C::*f)(void))
{
	return new Delegate0Impl<C, R>(c, f);
}

//////////////////////////////////////////////////////////////////////////
//delegate1
template<typename R, typename P1>
class Delegate1
{
public:
	virtual ~Delegate1(void){ }
	virtual R operator()(P1 p1) = 0;
};
template<typename C, typename R, typename P1>
class Delegate1Impl : public Delegate1<R, P1>
{
private:
	typedef R (C::*F)(P1);
	C* m_class;
	F m_fun;
public:
	Delegate1Impl(C* c, F f){ m_class = c; m_fun = f; }
	virtual R operator()(P1 p1)
	{
		if(m_class)
			return (m_class->*m_fun)(p1);
	}
};
template<typename C, typename R, typename P1>
Delegate1<R, P1>* MakeDelegate(C* c, R (C::*f)(P1))
{
	return new Delegate1Impl<C, R, P1>(c, f);
}

//////////////////////////////////////////////////////////////////////////
//delegate2
template<typename R, typename P1, typename P2>
class Delegate2
{
public:
	virtual ~Delegate2(void){ }
	virtual R operator()(P1 p1, P2 p2) = 0;
};
template<typename C, typename R, typename P1, typename P2>
class Delegate2Impl : public Delegate2<R, P1, P2>
{
private:
	typedef R (C::*F)(P1, P2);
	C* m_class;
	F m_fun;
public:
	Delegate2Impl(C* c, F f){ m_class = c; m_fun = f; }
	virtual R operator()(P1 p1, P2 p2)
	{
		if(m_class)
			return (m_class->*m_fun)(p1, p2);
	}
};
template<typename C, typename R, typename P1, typename P2>
Delegate2<R, P1, P2>* MakeDelegate(C* c, R (C::*f)(P1, P2))
{
	return new Delegate2Impl<C, R, P1, P2>(c, f);
}

//////////////////////////////////////////////////////////////////////////
//delegate3
template<typename R, typename P1, typename P2, typename P3>
class Delegate3
{
public:
	virtual ~Delegate3(void){ }
	virtual R operator()(P1 p1, P2 p2, P3 p3) = 0;
};
template<typename C, typename R, typename P1, typename P2, typename P3>
class Delegate3Impl : public Delegate3<R, P1, P2, P3>
{
private:
	typedef R (C::*F)(P1, P2, P3);
	C* m_class;
	F m_fun;
public:
	Delegate3Impl(C* c, F f){ m_class = c; m_fun = f; }
	virtual R operator()(P1 p1, P2 p2, P3 p3)
	{
		if(m_class)
			return (m_class->*m_fun)(p1, p2, p3);
	}
};
template<typename C, typename R, typename P1, typename P2, typename P3>
Delegate3<R, P1, P2, P3>* MakeDelegate(C* c, R (C::*f)(P1, P2, P3))
{
	return new Delegate3Impl<C, R, P1, P2, P3>(c, f);
}

}//namespace moxu
/*

class Test
{
public:
void test()
{
cout<<"p1"<<endl;
}
void test2(int a)
{
cout<<"P2 "<<a<<endl;
}
void test4(int a, int b, int c)
{
cout<<"P2 "<<a<<b<<c<<endl;
}
};

int main()
{
Test test;
Delegate0<void> *p = MakeDelegate(&test, Test::test);
(*p)();
Delegate1<void, int> *p2 = MakeDelegate(&test, Test::test2);
(*p2)(100);
Delegate3<void, int, int ,int> *p3 = MakeDelegate(&test, Test::test4);
(*p3)(100, 55,55);

//delete delegate
getch();
return 0;
}

*/