C#中delegate功能非常强大,使用起来也很方便,delegate使很多模式实现起来变得简单
C#中的代理,用C++看起来应该像这样 :
template<class T>
class Delegate
{
std::vector<T> _funs;
public:
Delegate& operator +=(const T& that)
{
_funs.push_back(that);
return *this;
}
Delegate& operator -=(const T& that)
{
std::vector<T>::iterator i = std::find(_funs.begin(),_funs.end(), that);
_funs.erase(i);
return *this;
}
void operator()()
{
for(std::vector<T>::iterator i=_funs.begin();i!=_funs.end();++i)
{
(*i)();
}
}
};
如果我们定义一个标准的函数
typedef void (*Test)();
void f1()
{
std::cout<<"f1"<<std::endl;
}
void f2()
{
std::cout<<"f2"<<std::endl;
}
void f3()
{
std::cout<<"f3"<<std::endl;
}
上面的代理基本可以用了
Delegate<Test> test1;
test1 += f1;
test1 += f2;
test1 += f3;
test1();
如果我们认为参数不够,我可以把标准的函数修改一下
typedef void (*Fun)(void* ,void*);
为此引入一个仿函数
template<class F,class obj=void,class para = void>
struct factor
{
obj *_this;
para*_param;
F _fun;
factor(const F& f,obj* pThis=NULL,para* data=NULL)
:_fun(f),_this(pThis),_param(data)
{
}
void operator()()
{
_fun(_this,_param);
}
bool operator==(const factor& that)
{
return _fun==that._fun&&_this==that._this;
}
};
测试一下效果,我们引入一个测试类AClass
class AClass
{
public:
static void ff2(AClass*pThis,void* data)
{
std::cout<<"AClass::ff2"<<std::endl;
}
void ff3(void* data)
{
std::cout<<"AClass::ff3"<<std::endl;
}
};
void ff1(AClass*pThis,void* data)
{
std::cout<<"AClass::f1"<<std::endl;
}
测试
AClass a;
Delegate<factor<Fun> > test2;
test2 += factor<Fun>((Fun)ff1,&a);
test2 += factor<Fun>((Fun)AClass::ff2,&a);
test2();
test2 -= factor<Fun>((Fun)AClass::ff2,&a);
test2();
能运行,可以数这个代理经过进一步完善后,应该可以适应大部分需要了,成员函数可以转化成静态成员函数h或全局函数,或者仿函数后用,如果不想转化, 可以这样
template<class F,class obj,class para = void>
struct factor_m:public factor<F,obj,para>
{
factor_m(const F& f,obj* pThis=NULL,para* data=NULL)
:factor(f,pThis,data)
{
}
void operator()()
{
(_this->*_fun)(_param);
}
};
使用
typedef void (AClass::*AF)(void *);
Delegate<factor_m<AF,AClass> > test3;
test3 += factor_m<AF,AClass> (&AClass::ff3,&a);
test3();
如果想用其他参数,上面的做法可以进一步完善,把参数中的void*变成其他结构,也可以用union,
struct arg
{
union
{
struct
{
int i[4];
};
struct
{
float f[4];
};
struct
{
void* pData;
};
...
};
};
如果还不满足,还想参数多一点,返回值多一点,建议参考Loki,引入TypeList,方法很巧妙,但不知道有多少人在用这种做法!!!