Делегаты на C++ - Александр Шаргин
Шрифт:
Интервал:
Закладка:
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) {
C_METHOD_DELEGATE‹TObj, TRet TEMPLATE_ARGS›* pMethodDel = dynamic_cast‹C_METHOD_DELEGATE‹TObj, TRet TEMPLATE_ARGS›*›(pDelegate);
if (pMethodDel == NULL || pMethodDel-›m_pObj != m_pObj || pMethodDel-›m_pMethod != m_pMethod) { return false; }
return true;
}
private:
TObj *m_pObj;
PMethod m_pMethod;
};
template‹class TRet TEMPLATE_PARAMS›
I_DELEGATE‹TRet TEMPLATE_ARGS›* NewDelegate(TRet (*pFunc)(PARAMS)) {
return new C_STATIC_DELEGATE‹TRet TEMPLATE_ARGS›(pFunc);
}
template ‹class TObj, class TRet TEMPLATE_PARAMS›
I_DELEGATE‹TRet TEMPLATE_ARGS›* NewDelegate(TObj* pObj, TRet (TObj::*pMethod)(PARAMS)) {
return new C_METHOD_DELEGATE‹TObj, TRet TEMPLATE_ARGS› (pObj, pMethod);
}
template‹class TRet TEMPLATE_PARAMS›
class C_DELEGATE {
public:
typedef I_DELEGATE‹TRet TEMPLATE_ARGS› IDelegate;
typedef std::list‹IDelegate*› DelegateList;
C_DELEGATE(IDelegate* pDelegate = NULL) { Add(pDelegate); }
~C_DELEGATE() { RemoveAll(); }
bool IsNull() { return (m_DelegateList.empty()); }
C_DELEGATE‹TRet TEMPLATE_ARGS›& operator=(IDelegate* pDelegate) {
RemoveAll();
Add(pDelegate);
return *this;
}
C_DELEGATE‹TRet TEMPLATE_ARGS›& operator+=(IDelegate* pDelegate) {
Add(pDelegate);
return *this;
}
C_DELEGATE‹TRet TEMPLATE_ARGS›& operator-=(IDelegate* pDelegate) {
Remove(pDelegate);
return *this;
}
TRet operator()(PARAMS) {
return Invoke(ARGS);
}
private:
void Add(IDelegate* pDelegate) {
if(pDelegate != NULL) m_DelegateList.push_back(pDelegate);
}
void Remove(IDelegate* pDelegate) {
DelegateList::iterator it;
for(it = m_DelegateList.begin(); it!= m_DelegateList.end(); ++it) {
if((*it)-›Compare(pDelegate)) {
delete (*it);
m_DelegateList.erase(it);
break;
}
}
}
void RemoveAll() {
DelegateList::iterator it;
for(it = m_DelegateList.begin(); it!= m_DelegateList.end(); ++it) delete (*it);
m_DelegateList.clear();
}
TRet Invoke(PARAMS) {
DelegateList::const_iterator it;
for (it = m_DelegateList.begin(); it != --m_DelegateList.end(); ++it) (*it)-›Invoke(ARGS);
return m_DelegateList.back()-›Invoke(ARGS);
}
private:
DelegateList m_DelegateList;
};
Вынеся обобщённый таким образом делегат в отдельный файл delegate_impl.h, мы можем сгенерировать его специализацию для любого количества параметров. Например, специализация делегата для пяти параметров получается так:
// 5 parameters…
#define SUFFIX 5
#define TEMPLATE_PARAMS
, class TP1, class TP2, class TP3, class TP4, class TP5
#define TEMPLATE_ARGS , TP1, TP2, TP3, TP4, TP5
#define PARAMS TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5
#define ARGS p1, p2, p3, p4, p5
#include "delegate_impl.h"
#undef SUFFIX
#undef TEMPLATE_PARAMS
#undef TEMPLATE_ARGS
#undef PARAMS
#undef ARGS
Подобные фрагменты для наборов от 0 до 10 параметров можно включить в отдельный файл delegate.h, который и будут подключать пользователи делегатов.
Вот пример использования библиотеки делегатов, которую мы только что получили. Обратите внимание, что он практически полностью соответствует примеру на языке C#, с которого началась эта статья.
