最近需要一个C++delegate的实现，比较接近C#的delegate的用法。翻遍了boost，虽然有相近的东西，但是，始终使用起来问题多多：
function:的绑定方式倒也可以接受，成员函数调用的方式实在不爽。而且，同样的函数原型，native和member对应的function类型不同，不同class的相同原型的member function类型也不同。
signal:用起来不错,但是，一来内置了slot装置，又不便于介入干扰，二来，如何绑定一般的成员函数，不知道如何实现，只能绑定native function和functor。
bind：正是我所要的。可惜，占位符最大到3。
还有个siglib++的库，昨天才看到，为时已晚。粗略的看了一下，调用的方法，似乎也是拖泥带水。
不是我喜欢自己发明轮子，实在是迫不得已，只好自己写delegate了。手写的代码不长，贴在下面共享：
/*
copywrite: 别逗了（非典型秃子）
Description: C++的delegate实现。
可以随意复制、修改、分发、使用。不要说是自己的就可以了。^_^
*/
#ifndef DELEGATE_H
#define DELEGATE_H
#include "contract.h"//自己的一个库，只和下面的一些断言有关。
namespace nice
{
template<typename T>
class delegate;
//长长的宏，没办法:(
#define DELEGATE(TEMPLATE_ARGS, FUNCTION_ARGS, FUNCTION_PARA)\
template< typename Ret TEMPLATE_ARGS >\
class delegate<Ret (FUNCTION_ARGS)>\
{\
struct FunctionHolder\
{\
virtual Ret operator()(FUNCTION_ARGS) = 0;\
virtual FunctionHolder* clone() const = 0;\
virtual ~FunctionHolder(){};\
};\
FunctionHolder* h;\
\
template<typename Functor>\
struct FunctorHolder : public FunctionHolder\
{\
Functor* Fun;\
FunctorHolder(Functor* nfun) : Fun(nfun){}\
virtual Ret operator()(FUNCTION_ARGS)\
{\
return (*Fun)(FUNCTION_PARA);\
}\
virtual FunctionHolder* clone() const\
{\
return new FunctorHolder(*this);\
}\
};\
\
template<typename U, typename MemFun>\
struct MemHolder : public FunctionHolder\
{ \
U obj;\
MemFun memFun; \
\
MemHolder(U aObj, MemFun amfun) \
: obj(aObj), memFun(amfun){}\
\
virtual Ret operator()(FUNCTION_ARGS) \
{\
return ((*obj).*memFun)(FUNCTION_PARA);\
}\
virtual FunctionHolder* clone() const\
{\
return new MemHolder(*this);\
}\
};\
FunctionHolder* cloneHolder() const\
{\
if (connected())\
return h->clone();\
return NULL;\
}\
public:\
delegate() : h(0)\
{\
}\
~delegate() \
{ \
disconnect(); \
} \
\
template<typename Functor>\
delegate(Functor* nfun_) \
: h(new FunctorHolder<Functor>(nfun_))\
{\
}\
\
delegate(const delegate& rhs) : h(rhs.cloneHolder())\
{}\
template <typename U, typename MemFun>\
delegate(U aObj, MemFun mFun) \
: h(new MemHolder<U, MemFun>(aObj, mFun))\
{ \
}\
delegate& operator=(const delegate& rhs)\
{\
if (&rhs != this)\
{\
disconnect();\
h = rhs.cloneHolder();\
}\
return *this;\
}\
template<typename Functor>\
void connect(Functor* nfun_)\
{ \
disconnect();\
h = new FunctorHolder<Functor>(nfun_);\
}\
\
template <typename U, typename MemFun>\
void connect(U aObj, MemFun mFun)\
{\
if (h) delete h;\
h = new MemHolder<U, MemFun>(aObj, mFun);\
}\
\
void disconnect() \
{ \
if (connected()) delete h; \
h = 0; \
} \
\
bool connected() const\
{\
return (h != NULL);\
}\
\
Ret operator()(FUNCTION_ARGS)\
{\
pre_condition(connected());\
return (*h)(FUNCTION_PARA);\
}\
};
//*/
#define TEMPLATE_ARGS_0
#define FUNCTION_ARGS_0
#define FUNCTION_PARA_0
#define TEMPLATE_ARGS_1 , typename T0
#define FUNCTION_ARGS_1 T0 t0
#define FUNCTION_PARA_1 t0
/* Defines Generate code:
for (int i = 2; i <= 50; i++)
{
printf("#define TEMPLATE_ARGS_%d TEMPLATE_ARGS_%d, typename T%d\n", i, i - 1, i - 1) ;
printf("#define FUNCTION_ARGS_%d FUNCTION_ARGS_%d, T%d t%d\n", i, i - 1, i - 1, i - 1);
printf("#define FUNCTION_PARA_%d FUNCTION_PARA_%d, t%d\n\n", i, i - 1, i - 1);
};
for (int i = 0; i <= 50; ++i)
printf("DELEGATE(TEMPLATE_ARGS_%d, FUNCTION_ARGS_%d, FUNCTION_PARA_%d)\n", i, i, i);
*/
//Auto Generate code:----------------------------------------------
#define TEMPLATE_ARGS_2 TEMPLATE_ARGS_1, typename T1
#define FUNCTION_ARGS_2 FUNCTION_ARGS_1, T1 t1
#define FUNCTION_PARA_2 FUNCTION_PARA_1, t1
....
#define TEMPLATE_ARGS_3 TEMPLATE_ARGS_2, typename T2
#define FUNCTION_ARGS_3 FUNCTION_ARGS_2, T2 t2
#define FUNCTION_PARA_3 FUNCTION_PARA_2, t2
#define TEMPLATE_ARGS_4 TEMPLATE_ARGS_3, typename T3
#define FUNCTION_ARGS_4 FUNCTION_ARGS_3, T3 t3
#define FUNCTION_PARA_4 FUNCTION_PARA_3, t3
...
DELEGATE(TEMPLATE_ARGS_0, FUNCTION_ARGS_0, FUNCTION_PARA_0)
DELEGATE(TEMPLATE_ARGS_1, FUNCTION_ARGS_1, FUNCTION_PARA_1)
DELEGATE(TEMPLATE_ARGS_2, FUNCTION_ARGS_2, FUNCTION_PARA_2)
DELEGATE(TEMPLATE_ARGS_3, FUNCTION_ARGS_3, FUNCTION_PARA_3)
...
};
#endif//end DELEGATE_H
测试用例：
CPPUNIT_TEST_SUITE_REGISTRATION(test_delegate);
using namespace nice;
int local_add(int a, int b)
{
return a + b;
}
struct functor_add
{
int m;
int mem_add(int a, int b)
{
return a + b + m;
}
};
struct functor_mul
{
int m;
int operator()(int a, int b)
{
return (a + b) * m;
}
};
void test_delegate::testMain()
{
typedef delegate<int(int, int)> testDele2;
//默认ctor没有连接上
testDele2 dele1;
CPPUNIT_ASSERT(!dele1.connected());
//connect
testDele2 dele2(local_add);
CPPUNIT_ASSERT(dele2.connected());
//调用
CPPUNIT_ASSERT(dele2(2, 3) == 5);
//copy ctor
testDele2 dele3 = dele2;
CPPUNIT_ASSERT(dele3.connected());
CPPUNIT_ASSERT(dele3(2, 3) == 5);
//disconnect
dele2.disconnect();
CPPUNIT_ASSERT(!dele2.connected());
//test clone
CPPUNIT_ASSERT(dele3.connected());
dele3(2, 3);
CPPUNIT_ASSERT(dele3(2, 3) == 5);
//assign
dele2 = dele3;
CPPUNIT_ASSERT(dele2(2, 3) == 5);
//member function
functor_add fctor;
fctor.m = 7;
dele2.connect(&fctor, &functor_add::mem_add);
CPPUNIT_ASSERT(dele2(2, 3) == 12);
//functor
functor_mul fm;
fm.m = 3;
testDele2 dele4(&fm);
CPPUNIT_ASSERT(dele4(2, 3) == 15);
fm.m = 4;
CPPUNIT_ASSERT(dele4(2, 3) == 20);
dele2.connect(&fm);
}
|
本类阅读TOP10