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

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;
};

Для реализации необходимого набора операторов используются вспомогательные методы Add, Remove, RemoveAll и Invoke. Метод Add добавляет новый указатель IDelegateVoid* в список:

void CDelegateVoid::Add(IDelegateVoid* pDelegate) {
 if (pDelegate != NULL) m_DelegateList.push_back(pDelegate);
}

Метод Remove ищет в списке делегат, ссылающийся на заданную функцию, и в случае обнаружения удаляет его:

void CDelegateVoid::Remove(IDelegateVoid* pDelegate) {
 std::list‹IDelegateVoid*›::iterator it;
 for(it = m_DelegateList.begin; it!= m_DelegateList.end; ++it) {
 if((*it)-›Compare(pDelegate)) {
 delete (*it);
 m_DelegateList.erase(it);
 break;
 }
 }
 delete pDelegate;
}

Метод RemoveAll просто очищает список, удаляя из него все делегаты:

void CDelegateVoid::RemoveAll {
 std::list‹IDelegateVoid*›::iterator it;
 for(it = m_DelegateList.begin; it != m_DelegateList.end; ++it) delete (*it);
 m_DelegateList.clear;
}

Наконец, метод Invoke вызывает все функции и методы, на которые ссылаются делегаты из списка:

void CDelegateVoid::Invoke {
 std::list‹IDelegateVoid*›::const_iterator it;
 for (it = m_DelegateList.begin; it != m_DelegateList.end; ++it) (*it)-›Invoke;
}

Использовать полученный класс делегата можно примерно так.

void Global {
 std::cout ‹‹ "Global" ‹‹ std::endl;
}

class C {
public:
 void Method { std::cout ‹‹ "Method" ‹‹ std::endl; }
 static void StaticMethod { std::cout ‹‹ "StaticMethod" ‹‹ std::endl; }
};

int main {
 C c;
 CDelegateVoid delegate = NewDelegate(Global);
 delegate += NewDelegate(&c, &C::Method);
 delegate += NewDelegate(C::StaticMethod);

 delegate; // вызывается Global, Method и StaticMethod.

 delegate -= NewDelegate(C::StaticMethod);
 delegate -= NewDelegate(Global);
 delegate; // вызывается только Method.
 return 0;
}

Как видим, класс CDelegateVoid очень похож на делегаты из C#. Он полностью типобезопасен, так как попытка передать функции NewDelegate ссылку на функцию или метод, сигнатура которых отличается от void(void), немедленно приведёт к ошибке. Реализация класса CDelegateVoid не использует никаких предположений о размере и устройстве указателя на метод класса, поэтому он может использоваться как при обычном, так и при множественном и виртуальном наследовании. Его можно без изменений переносить на новые платформы и компиляторы.