Делегаты, сигналы и слоты.

Как известно, в C++ делегатов нет. А жаль.
Впринципе, в интернете много делегатов. И слотов много. Но, я зачем-то решил написать свои.

Благодаря механикам: официальной — variadic templates и неофициальной — horrible_cast реализация делегатов оказалось компактной, хотя, у нее, возможно и будут проблемы с переносимостью (не зря же у нормальных людей в реализациях трёхэтажная шаблонная магия и двухэтажная препроцессорная).

Платформа на которой всё запустилось — avr2560 в виде Ардуино. К статье прилагаю сию работу в виде Ардуино библиотеки.

Значительно упрощает реализацию делегата отказ от использования множества различных сигнатур применительно к одному делегату. (Хоть убейте, не знаю, зачем оно людям нужно). Действительно, если объявить делегат шаблонным с самого начала и явно прописать его сигнатуру, не приходится изобретать хитрых методов востановления сигнатуры.

Механика сохранения информации делегата у нас следующая следующая.
1. Делегат инициализируется парой указатель на объект и указатель на метод класса.
2. Указатель на объект приводится к указателю на тип Abstract.
3. Указатель на метод класса приводится к указателю на метод класса Abstract (спасибо horrible_cast)
4. Полученные указатели сохраняются в отведённых полях.

В этом процессе мы теряем информацю о типе объекта, но оказывается, что для корректного вызова метода тип знать совсем не обязательно.

Механика вызова делегата и того проще. Мы просто вызываем с передаваемыми оператору вызова параметрами метод, якобы, Abstract класса по сохранённому указателю на метод и сохранённому указателю на объект. Удивительно, но это работает.

Собственно, вот что из себя представляет основа делегата:

template<typename OutputType ,typename ... VarTypes>	
	class delegate
	{public:
		
		class Abstract{};
		
		typedef Abstract* delegate_obj_t;			
		typedef OutputType (Abstract::*delegate_mtd_t)(VarTypes ...);
		
		delegate_obj_t object;
		delegate_mtd_t method;
		
	....

Вот типичный конструктор:

//Конструктор. Делегат метода класса. 
		//@1 указатель на объект, метод которого вызывается.
		//@2 указатель на метод.
		//Пример delegate<void, int> d(&a, &A::func);
		template<typename T1, typename T2>
		delegate(T1* ptr_obj, OutputType(T2::*mtd)(VarTypes ...))  : function(0)
		{
			object = reinterpret_cast <delegate_obj_t> (ptr_obj);
			method = horrible_cast<delegate_mtd_t, OutputType(T2::*)(VarTypes ...)>(mtd);
		};	

Вот вызов:

OutputType operator()(VarTypes ... arg) {
				return (object->*method)(arg ...);
			};

Всё… Если вы откроете файл delegate.h в выложенной мной библиотеке, вы увидите, что реализация немного сложнее из-за некоторых дополнительных механизмов инициализации и из-за добавления возможности вызова обычных, не являющихся членами класса функций. У них точно такая же сигнатура, так что проблем с этим не возникает.

Использование:

class A
{
void mtd(int){};
} a;

void fnc(int){};
void fnc2(int){};

delegate<void, int> d1 = fnc;
d1(3);
d1 = fnc2;
d1(4);
delegate<void, int> d2(&a, &A::mtd);
delegate<void, int> d3 = method(a, A::mtd);

Первый параметр шаблона — возвращаемое значение. Дальше типы параметров в любом количестве.
Макрос method введён специально для передачи значений в конструктор через знак присваивания.
(операторы присваивания неопределены, а потому присваивание вызывает конструктор).

Пожалуй, здесь всё.

На основе данной реализации делегатов и механики monolist строится sigslot библиотека. Класс sigslot — класс сигнала. В качестве слота выступает любая функция или метод с такой же сигнатурой.
Вызов sigslot через operator() приводит к последовательному выполнению всех находящихся в списке делегатов (с переданными параметрами, разумеется).

Библиотека использует динамическую память для хранения делегатов. Алгоритм работы, вероятно, медленней других реализаций, особенно разворачивающихся на этапе компиляции. В данной реализации вся работа выполняется в реалтайме.

Библиотека перегружает для класса sigslot операторы

+= — добавление метода или функции.
!= — приоритетное добавление метода.
-= — удаление метода.

По умолчанию последний добавленный будет последним же исполняться. Приоритетное добавление ставит добавляемую функцию в начала списка. Такая функция исполняется первой.
Удаление метода заключается к поиску в списке записи, аналогичной переданной функции и удалению ее.
При вызове сигнал возвращает то, что вернул последний объект. Не знаю, зачем…

Пример использования:

s += func;
  s += method(a, A::mtd);
  s(3, 0.97);

Рассказывать о том, как оно работает я не буду, ибо реализация чуть менее чем полностью состоит из нудных операций по работе со списками и ничего реально интересного, кроме того, что я уже рассказал там нет.

Если вы до сюда дочитали, спасибо.

Прилагаю Ардуино библиотеку с реализацией. В файлах приводится довольно подробный комментарий о том, что зачем и с какими параметрами вызывается.