Делегаты на C++

};

Метод Compare должен проверить, что переданный ему указатель IDelegateVoid* в действительности ссылается на объект CStaticDelegateVoid. Если это не так, делегаты различны (ссылаются на разные функции) и Compare просто возвращает false. Иначе результат определяется сравнением переменных-членов m_pFunc у двух объектов. Реализация этой идеи выглядит так.

bool CStaticDelegateVoid::Compare(IDelegateVoid *pDelegate) {
 CStaticDelegateVoid* pStaticDel = dynamic_cast‹CStaticDelegateVoid*›(pDelegate);
 if (pStaticDel == NULL || pStaticDel-›m_pFunc != m_pFunc) return false;
 return true;
}

Класс CMethodDelegateVoid чуть-чуть сложнее. Он должен инкапсулировать указатель на объект и указатель на метод этого объекта. Поскольку в C++ указатели на методы двух разных классов принципиально отличаются (и могут даже иметь разный размер), нам нужна отдельная реализация CMethodDelegateVoid для каждого нового класса, на методы которого мы хотим ссылаться. Поэтому класс CMethodDelegateVoid должен быть шаблоном. В остальном его реализация аналогична CStaticDelegateVoid.

template‹class TObj›
class CMethodDelegateVoid: public IDelegateVoid {
public:
 typedef void (TObj::*PMethod)();
 CMethodDelegateVoid(TObj* pObj, PMethod pMethod) {
  m_pObj = pObj;
  m_pMethod = pMethod;
 }
 virtual void Invoke() {
 (m_pObj-›*m_pMethod)();
 }
 virtual bool Compare(IDelegateVoid* pDelegate);
private:
 TObj *m_pObj;
 PMethod m_pMethod;
};
template‹class TObj›
bool CMethodDelegateVoid‹TObj›::Compare(IDelegateVoid* pDelegate) {
 CMethodDelegateVoid‹TObj›* pMethodDel = dynamic_cast‹CMethodDelegateVoid‹TObj›* ›(pDelegate);
 if (pMethodDel == NULL || pMethodDel-›m_pObj != m_pObj || pMethodDel-›m_pMethod != m_pMethod) return false;
 return true;
}

Классы CStaticDelegateVoid и CMethodDelegateVoid можно использовать непосредственно. Но для пользователя удобнее работать исключительно с интерфейсом IDelegateVoid, не задумываясь о существовании двух различных классов реализации. Поэтому напишем перегруженную функцию NewDelegate, которая будет создавать нужный объект и возвращать пользователю IDelegateVoid*. Её реализация будет выглядеть так:

IDelegateVoid* NewDelegate(void (*pFunc)()) {
 return new CStaticDelegateVoid(pFunc);
}
template ‹class TObj›
IDelegateVoid* NewDelegate(TObj* pObj, void (TObj::*pMethod)()) {
 return new CMethodDelegateVoid‹TObj› (pObj, pMethod);
}

Мы уже почти закончили. Осталось написать объектную обёртку над интерфейсом IDelegateVoid, которая будет поддерживать список указателей и определять набор операторов, аналогичных используемым в C# - operator=, operator(), operator+= и operator-=. Для простоты будем использовать стандартный класс std::list для хранения списка указателей.

#include ‹list›
class CDelegateVoid {
public:
 CDelegateVoid(IDelegateVoid* pDelegate = NULL) {
 Add(pDelegate);
}
 ~CDelegateVoid() { RemoveAll(); }
 bool IsNull() { return (m_DelegateList.size() == 0); }
 CDelegateVoid& operator=(IDelegateVoid* pDelegate) {
  RemoveAll();
  Add(pDelegate);
  return *this;
 }
 CDelegateVoid& operator+=(IDelegateVoid* pDelegate) {
  Add(pDelegate);
  return *this;
 }
 CDelegateVoid& operator-=(IDelegateVoid* pDelegate) {
  Remove(pDelegate);
  return *this;
 }
 void operator()() { Invoke(); }
private:
 void Add(IDelegateVoid* pDelegate);
 void Remove(IDelegateVoid* pDelegate);
 void RemoveAll();
 void Invoke();
private:
 std::list‹IDelegateVoid*› m_DelegateList;
};

Для реализации необходимого набора операторов используются вспомогательные методы