Александр Шаргин - Делегаты на C++

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не использует никаких предположений о размере и устройстве указателя на метод класса, поэтому он может использоваться как при обычном, так и при множественном и виртуальном наследовании. Его можно без изменений переносить на новые платформы и компиляторы.

Теперь посмотрим, как можно обобщить класс CDelegateVoidдля применения с различными сигнатурами. Используя шаблоны, мы можем параметризовать как тип возвращаемого значения, так и типы параметров функций, на которые ссылаются делегаты. В то же время, мы не можем определить единый шаблон, поддерживающий разное количество параметров, поэтому для каждого количества параметров необходимо реализовать свой класс. Поскольку наборы от 0 до 10 параметров покрывают 99% практических нужд при работе с делегатами, нам нужно написать 11 шаблонов делегатов CDelegate0, CDelegate1,…, CDelegate10. Вот как будет начинаться описание делегата, который возвращает произвольное значение и принимает произвольный (но ровно 1) параметр.

template‹class TRet, class TP1›

class IDelegate1 {

public:

virtual ~IDelegate1() {}

virtual TRet Invoke(TP1) = 0;

virtual bool Compare(IDelegate1‹TRet, TP1›* pDelegate) = 0;

};

template‹class TRet, class TP1›

class CStaticDelegate1: public IDelegate1‹TRet, TP1› {

public:

typedef TRet (*PFunc)(TP1);

CStaticDelegate1(PFunc pFunc) { m_pFunc = pFunc; }

virtual TRet Invoke(TP1 p1) { return m_pFunc(p1); }

virtual bool Compare(IDelegate1‹TRet, TP1›* pDelegate) {

CStaticDelegate1‹TRet, TP1›* pStaticDel = dynamic_cast‹CStaticDelegate1‹TRet, TP1›* ›(pDelegate);

if (pStaticDel == NULL || pStaticDel-›m_pFunc != m_pFunc) return false;

return true;

}

private:

PFunc m_pFunc;

};

Как видим, мы вынуждены постоянно "таскать" за собой список параметров шаблона ‹TRet, TP1›. Для делегата с 10-ю параметрами эти списки полностью загромоздят код. Кроме того, вручную дублировать практически идентичные классы 11 раз - не самая удачная идея. Чтобы избежать лишнего дублирования кода, прибегнем к самому сильнодействующему (и самому опасному) средству языка C++ - препроцессору. Идея состоит в том, чтобы обозначить различающиеся участки кода в реализации классов CDelegateXмакросами. Эти различающиеся участки можно разделить на 4 типа:

• Параметры шаблонов (например, ‹…, class TP1, class TP2, class TP3›). Список параметров шаблона обозначим макросом TEMPLATE_PARAMS.

• Аргументы шаблонов (например, ‹…, TP1, TP2, TP3›). Список аргументов шаблона обозначим макросом TEMPLATE_ARGS.

• Параметры функции Invoke(например, (TP1 p1, TP2 p2, TP3 p3)). Список этих параметров обозначим макросом PARAMS.

• Аргументы функции Invoke(например, (p1, p2, p3)). Список этих аргументов обозначим макросом ARGS.

Кроме этих макросов, нам потребуется макрос SUFFIX, который принимает значения от 0 до 10 и дописывается к именам классов следующим образом:

#define COMBINE(a,b) COMBINE1(a,b)

#define COMBINE1(a,b) a##b

#define I_DELEGATE COMBINE(IDelegate, SUFFIX)

#define C_STATIC_DELEGATE COMBINE(CStaticDelegate, SUFFIX)

#define C_METHOD_DELEGATE COMBINE(CMethodDelegate, SUFFIX)

#define C_DELEGATE COMBINE(CDelegate, SUFFIX)

ПРИМЕЧАНИЕОбратите внимание на использование вспомогательного макроса COMBINE1. Если напрямую реализовать макрос COMBINEкак #define COMBINE(a,b) a##b, то результатом подстановки COMBINE(IDelegate, SUFFIX)будет " IDelegateSUFFIX". А это совсем не то, что мы хотим получить. Поэтому использование COMBINE1в данном случае необходимо.

Окончательная версия делегата, обобщённая с помощью всех этих макросов, будет выглядеть так:

template‹class TRet TEMPLATE_PARAMS›

class I_DELEGATE {

public:

virtual ~I_DELEGATE() {}

virtual TRet Invoke(PARAMS) = 0;

virtual bool Compare(I_DELEGATE‹TRet TEMPLATE_ARGS›* pDelegate) = 0;

};

template‹class TRet TEMPLATE_PARAMS›

class C_STATIC_DELEGATE: public I_DELEGATE‹TRet TEMPLATE_ARGS› {

public:

typedef TRet (*PFunc)(PARAMS);

C_STATIC_DELEGATE(PFunc pFunc) { m_pFunc = pFunc; }

virtual TRet Invoke(PARAMS) { return m_pFunc(ARGS); }

virtual bool Compare(I_DELEGATE‹TRet TEMPLATE_ARGS›* pDelegate) {

C_STATIC_DELEGATE‹TRet TEMPLATE_ARGS›* pStaticDel = dynamic_cast‹C_STATIC_DELEGATE‹TRet TEMPLATE_ARGS›*›(pDelegate);

if (pStaticDel == NULL || pStaticDel-›m_pFunc != m_pFunc) return false;

return true;

}

private:

PFunc m_pFunc;

};

template‹class TObj, class TRet TEMPLATE_PARAMS›

class C_METHOD_DELEGATE: public I_DELEGATE‹TRet TEMPLATE_ARGS› {

public:

typedef TRet (TObj::*PMethod)(PARAMS);

C_METHOD_DELEGATE(TObj* pObj, PMethod pMethod) {

m_pObj = pObj;

m_pMethod = pMethod;

}

virtual TRet Invoke(PARAMS) { return (m_pObj-›*m_pMethod)(ARGS); }

virtual bool Compare(I_DELEGATE‹TRet TEMPLATE_ARGS›* pDelegate) {