用 C++ 实现 C# 中的 委托/事件 (2-delegate event functor)

前两天看程序员杂志
看到关于 C# 中的委托/事件
觉得用起来好像是挺方便的
本人热衷于 C++
想想用 C++ 来模拟似乎也可以
于是就有了下面的代码...
(VC6 不支持偏特化 本人工作环境就是 VC6 痛啊~~~)

没有返回值的函数用 delegate
否则就用 delegate_rt
functor 也一样 functorN/functorN_rt
delegate 的模板参数可以是函数指针(非成员函数)
也可以是 functor
还可以是 delegate
functor 可用 make_functor/make_functor_rt 来生成
要是有偏特化 就可以去掉讨厌的 _rt 了 :(

关于委托 boost里有现成的
不过可能 VC6 里用不了

这些代码旨在个人研究
如果大家发现其中问题 希望能指出

//filename: delegate.h
#ifndef _DELEGATE_H_
#define _DELEGATE_H_

#include <vector>
#include <algorithm>
#include "delegate_rt.h"

template <typename T>
class delegate
{
protected:
  std::vector<T> funcs;
public:
  typedef T FunctorType;

  delegate() {}
  explicit delegate(T Func)
  {
    if (!(Func == NULL)) funcs.push_back(Func);
  }
  delegate(const delegate& rhs) : funcs(rhs.funcs) {}

  void operator ()() const
  {
    typename std::vector<T>::const_iterator i = funcs.begin();
    for (; i != funcs.end(); ++i)
    {
      (*i)();
    }
  }
 template <typename P1>
  void operator ()(P1 p1) const
  {
    typename std::vector<T>::const_iterator i = funcs.begin();
    for (; i != funcs.end(); ++i)
    {
      (*i)(p1);
    }
  }
 template <typename P1, typename P2>
  void operator ()(P1 p1, P2 p2) const
  {
    typename std::vector<T>::const_iterator i = funcs.begin();
    for (; i != funcs.end(); ++i)
    {
      (*i)(p1, p2);
    }
  }
  bool operator ==(const delegate& rhs) const
  {
    return funcs == rhs.funcs;
  }
  bool operator ==(const void* rhs) const
  {
    if (funcs.size())
      return &funcs == rhs;
    return NULL == rhs;
  }

  delegate& operator =(const delegate& rhs)
  {
    funcs = rhs.funcs;
    return *this;
  }
  delegate& operator +=(const delegate& rhs)
  {
    if (this == &rhs)
      return *this;
    typename std::vector<T>::const_iterator j, i = rhs.funcs.begin();
    for (; i != rhs.funcs.end(); ++i)
    {
      j = std::find(funcs.begin(), funcs.end(), *i);
      if (j == funcs.end())
        funcs.push_back(*i);
    }
    return *this;
  }
  delegate& operator -=(const delegate& rhs)
  {
    if (this == &rhs)
    {
      funcs.clear();
      return *this;
    }
    typename std::vector<T>::iterator j;
    typename std::vector<T>::const_iterator i = rhs.funcs.begin();
    for (; i != rhs.funcs.end(); ++i)
    {
      j = std::find(funcs.begin(), funcs.end(), *i);
      if (j != funcs.end())
        funcs.erase(j);
    }
    return *this;
  }
  delegate operator +(const delegate& rhs) const
  {
    return delegate(*this) += rhs;
  }
  delegate operator -(const delegate& rhs) const
  {
    return delegate(*this) -= rhs;
  }

  delegate& operator =(T rhs)
  {
    funcs.clear();
    if (!(rhs == NULL))
      funcs.push_back(rhs);
    return *this;
  }
  delegate& operator +=(T rhs)
  {
    if (rhs == NULL)
      return *this;
    typename std::vector<T>::const_iterator j = 
      std::find(funcs.begin(), funcs.end(), rhs);
    if (j == funcs.end())
      funcs.push_back(rhs);
    return *this;
  }
  delegate& operator -=(T rhs)
  {
    if (rhs == NULL)
      return *this;
    typename std::vector<T>::iterator j = 
      std::find(funcs.begin(), funcs.end(), rhs);
    if (j != funcs.end())
      funcs.erase(j);
    return *this;
  }
  delegate operator +(T rhs) const
  {
    return delegate(*this) += rhs;
  }
  delegate operator -(T rhs) const
  {
    return delegate(*this) -= rhs;
  }
  friend delegate operator +(T lhs, const delegate& rhs)
  {
    return rhs + lhs;
  }
};

#endif // #ifndef _DELEGATE_H_

//filename: delegate_rt.h
#ifndef _DELEGATE_RT_H_
#define _DELEGATE_RT_H_

#include <vector>
#include <algorithm>
#include <stdexcept>

template <typename R, typename T>
class delegate_rt
{
protected:
  std::vector<T> funcs;
public:
  typedef T FunctorType;
  typedef R ReturnType;

  delegate_rt() {}
  explicit delegate_rt(T Func)
  {
    if (!(Func == NULL)) funcs.push_back(Func);
  }
  delegate_rt(const delegate_rt& rhs) : funcs(rhs.funcs) {}

  ReturnType operator ()() const
  {
    if (funcs.size() != 1)
      throw std::runtime_error("non-multicast delegate: method error!");
    return funcs.front()();
  }
 template <typename P1>
  ReturnType operator ()(P1 p1) const
  {
    if (funcs.size() != 1)
      throw std::runtime_error("non-multicast delegate: method error!");
    return funcs.front()(p1);
  }
 template <typename P1, typename P2>
  ReturnType operator ()(P1 p1, P2 p2) const
  {
    if (funcs.size() != 1)
      throw std::runtime_error("non-multicast delegate: method error!");
    return funcs.front()(p1, p2);
  }
  bool operator ==(const delegate_rt& rhs) const
  {
    return funcs == rhs.funcs;
  }
  bool operator ==(const void* rhs) const
  {
    if (funcs.size())
      return &funcs == rhs;
    return NULL == rhs;
  }

  delegate_rt& operator =(const delegate_rt& rhs)
  {
    funcs = rhs.funcs;
    return *this;
  }
  delegate_rt& operator +=(const delegate_rt& rhs)
  {
    if (this == &rhs)
      return *this;
    typename std::vector<T>::const_iterator j, i = rhs.funcs.begin();
    for (; i != rhs.funcs.end(); ++i)
    {
      j = std::find(funcs.begin(), funcs.end(), *i);
      if (j == funcs.end())
        funcs.push_back(*i);
    }
    return *this;
  }
  delegate_rt& operator -=(const delegate_rt& rhs)
  {
    if (this == &rhs)
    {
      funcs.clear();
      return *this;
    }
    typename std::vector<T>::iterator j;
    typename std::vector<T>::const_iterator i = rhs.funcs.begin();
    for (; i != rhs.funcs.end(); ++i)
    {
      j = std::find(funcs.begin(), funcs.end(), *i);
      if (j != funcs.end())
        funcs.erase(j);
    }
    return *this;
  }
  delegate_rt operator +(const delegate_rt& rhs) const
  {
    return delegate_rt(*this) += rhs;
  }
  delegate_rt operator -(const delegate_rt& rhs) const
  {
    return delegate_rt(*this) -= rhs;
  }

  delegate_rt& operator =(T rhs)
  {
    funcs.clear();
    if (!(rhs == NULL))
      funcs.push_back(rhs);
    return *this;
  }
  delegate_rt& operator +=(T rhs)
  {
    if (rhs == NULL)
      return *this;
    typename std::vector<T>::const_iterator j = 
      std::find(funcs.begin(), funcs.end(), rhs);
    if (j == funcs.end())
      funcs.push_back(rhs);
    return *this;
  }
  delegate_rt& operator -=(T rhs)
  {
    if (rhs == NULL)
      return *this;
    typename std::vector<T>::iterator j = 
      std::find(funcs.begin(), funcs.end(), rhs);
    if (j != funcs.end())
      funcs.erase(j);
    return *this;
  }
  delegate_rt operator +(T rhs) const
  {
    return delegate_rt(*this) += rhs;
  }
  delegate_rt operator -(T rhs) const
  {
    return delegate_rt(*this) -= rhs;
  }
  friend delegate_rt operator +(T lhs, const delegate_rt& rhs)
  {
    return rhs + lhs;
  }
};

#endif // #ifndef _DELEGATE_RT_H_
 
 
//filename: event.h
#ifndef _EVENT_H_
#define _EVENT_H_

typedef void* object;

class EventArgs
{
public:
  bool cancel;
  EventArgs() : cancel(false) {}
};

template <typename T>
class event
{
  T handlers;
public:
  void operator +=(const T& rhs)
  {
    handlers += rhs;
  }
  void operator -=(const T& rhs)
  {
    handlers -= rhs;
  }
  void operator()() const
  {
    handlers(NULL, EventArgs());
  }
   template <typename P1>
  void operator()(P1 p1) const
  {
    handlers(p1, EventArgs());
  }
   template <typename P1, typename P2>
  void operator()(P1 p1, P2 p2) const
  {
    handlers(p1, p2);
  }
};

#endif // #ifndef _EVENT_H_
 
//filename: functor.h
#ifndef _FUNCTOR_H_
#define _FUNCTOR_H_

template<typename T, typename T1, typename T2, typename T3>
class functor_base
{
public:
  typedef T deleobject;
  typedef T1 func_pt;
  typedef T2 mem_func_pt;
  typedef T3 cmem_func_pt;
  union
  {
    func_pt m_pf;
    mem_func_pt m_pmf;
    cmem_func_pt m_pcmf;
  };
  union
  {
    deleobject *m_pObject;
    const deleobject *m_pcObject;
  };
  functor_base() : m_pf(NULL), m_pObject(NULL) {}
  functor_base(func_pt pf) : 
    m_pf(pf), m_pObject(NULL) {}
  functor_base(const deleobject *pObject, mem_func_pt pf) : 
    m_pmf(pf), m_pcObject(pObject) {}
  functor_base(const deleobject *pObject, cmem_func_pt pf) : 
    m_pcmf(pf), m_pcObject(pObject) {}
  bool operator !=(const functor_base& rhs) const { return !(*this == rhs); }
  bool operator ==(const functor_base& rhs) const
  {
    if (m_pObject == NULL)
      return rhs.m_pObject == NULL && m_pf == rhs.m_pf;
    return m_pObject == rhs.m_pObject && m_pmf == rhs.m_pmf;
  }
  bool operator ==(const void* rhs) const
  {
    return m_pObject == NULL ? m_pf == rhs : *(const void**)&m_pmf == rhs;
  }
  functor_base& operator =(const functor_base& rhs)
  {
    if (&rhs == this)
      return *this;
    m_pObject = rhs.m_pObject;
    if (m_pObject == NULL)
      m_pf = rhs.m_pf;
    else
      m_pmf = rhs.m_pmf;
    return *this;
  }
};

#include "functor0.h"
#include "functor1.h"
#include "functor2.h"
#include "functor0_rt.h"
#include "functor1_rt.h"
#include "functor2_rt.h"

#endif // #ifndef _FUNCTOR_H_