一个C++ delegate的实现

一个C++ delegate的实现

更新说明：
修改了借口，增加了对smart_ptr的支持。

最近需要一个C++delegate的实现，比较接近C#的delegate的用法。翻遍了boost，虽然有相近的东西，但是，始终使用起来问题多多：
function:的绑定方式倒也可以接受，成员函数调用的方式实在不爽。而且，同样的函数原型，native和member对应的function类型不同，不同class的相同原型的member function类型也不同。
signal:用起来不错,但是，一来内置了slot装置，又不便于介入干扰，二来，如何绑定一般的成员函数，不知道如何实现，只能绑定native function和functor。
bind：正是我所要的。可惜，占位符最大到3。
还有个siglib++的库，昨天才看到，为时已晚。粗略的看了一下，调用的方法，似乎也是拖泥带水。
不是我喜欢自己发明轮子，实在是迫不得已，只好自己写delegate了。手写的代码不长，贴在后面共享.

Deltegate的使用 
一．说明：
delegate的用法和C#的有些类似，相对来说还是比较简洁的。实现上，代码并不复杂。没有怎么考虑移植性的问题。 

二．使用：

1．例子

delegate<int(int, int)> dele_binary;

定义了一个委托：dele_binary, dele_binary可以持有如下形式的函数：

1. int navive_fun(int, int);
2. struct functor{

int operator()(int, int);

} a_functor;

3. struct A{

int mem_fun(int, int);

} an_a;

绑定delegate到实际的函数的过程：

dele_binary.connect(&native_fun);  //绑定到普通函数，&运算符是可选的

dele_binary.connect(&a_functor);      //绑定到仿函数，&是必须的

dele_binary.connect(&an_a, &A::mem_fun); //绑定到普通成员函数，两个&都是必须的

注意：dele_binary类型定义的模版参数是：int(int, int)的形式，不要加上*，这可以参考boost::function。这样写是符合标准的，缺点是可能移植性暂时会受到影响。

 

2．调用方式

delegate重载了operator(),对于上述的三种绑定过程，具有统一的调用形式：

int x = dele_binary(1,2);

delegate重载了operator()。同时，可以注意到，例子中的差别只在于connect的形式不同，dele_binary的数据类型是确定的，因此，delegate可以放入容器当中，也可以无差别的调用。此外，delegate本身也是一个functor，也可以放入另一个delegate中，一般而言，建议避免这样做。

为了方便使用，也允许在delegate的构造函数中直接连接被委托的对象，形式如下：

delegate<int(int, int)> dele_binary (&native_fun); 

delegate<int(int, int)> dele_binary (&a_functor);     

delegate<int(int, int)> dele_binary (&an_a, &A::mem_fun);

在通过delegate调用被委托对象之前，必须确保delegate实例已经连接到某个对象。可以通过connected方法检查，是否已经连接到确定对象。也可以通过disconnect断开和对象的连接。方法原型如下：

bool connected() const；

void disconnect()；

 

3．Copy & assignment

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 FunctorPtr>/
  struct FunctorHolder : public FunctionHolder/
  {/
   FunctorPtr Fun;/
   FunctorHolder(FunctorPtr 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 FunctorPtr>/
  delegate(FunctorPtr nfun_) /
   : h(new FunctorHolder<FunctorPtr>(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 FunctorPtr>/
  void connect(FunctorPtr nfun_)/
  {  /
   disconnect();/
   h = new FunctorHolder<FunctorPtr>(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);
 
 //smart ptr
 boost::shared_ptr<functor_mul> sh_ptr(new functor_mul);
 (*sh_ptr).m = 10; 
 
 dele2.connect(sh_ptr);
 CPPUNIT_ASSERT(dele2(2, 3) == 50);
}