C#delegate的C++简易实现

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，方法很巧妙，但不知道有多少人在用这种做法！！！