Классы std::function и boost::function являются высокоуровневыми обертками над функциями и функциональными объектами. Объекты таких классов позволяют хранить и вызывать функции и функторы с заданной сигнатурой, что бывает удобно, например, при создании callback вызовов (например, мы можем регистрировать несколько обработчиков, и это могут быть как обычные функции, так и объекты с определенным оператором =)
Если вам интересно, каким образом реализуется данный функционал, то прошу под кат
Краткое введение, примеры использования
Если вы не знакомы с boost::function и std::function, то можно ознакомиться с ними здесь и здесь
std::function входит в стандарт языка c++11, и компиляторы gcc-4.7 и msvc-2012 его поддерживают (возможно, более ранние версии тоже имеют поддержку). В принципе, в рамках этой статьи можно считать реализацию от boost и стандартную полностью идентичными, так что пользоваться можно любой из реализаций
Собственно пример использования:
int func1() {
return 0;
}
struct callable {
int operator() () {
return 1;
}
};
///...
boost::function<int (void)> x;
x = func1;
int res = x(); // вернет 0 в качестве результата
callable c;
x = c;
res = x(); // вернет 1 в качестве результатаПереходим к самой реализации
Саму реализацию будем делать в несколько этапов:
- Самый простой use-case — инициализировать наш объект указателем на функцию или объектом-функцией и вызвать оператор ()
- Поддержка операторов присваивания и копирующего конструктора
- Поддержка указателей на функции-члены
Самая простая реализация, понятие Type erasure
В основе реализации данного класса лежит паттерн Type Erasure, более доступно можно почитать здесь Его предназначение заключается в том, что мы можем «спрятать» за одним интерфейсом различные сущности (объекты, указатели и пр.), которые предоставляют сходные возможности (например, осуществить вызов функции с тремя аргументами). Type erasure также можно представить как мостик, который связывает полиморфизм времени исполнения (runtime polymorfism) и полиморфизм времени компиляции (compile-time polymorfism).
Итак, переходим к реализации.
Мы будем использовать variadic templates из стандарта C++11. Например, gcc поддерживает этот функционал аж с версии 4.3, поэтому можно смело им пользоваться.
Не будем оригинальны и назовем наш класс function. Очевидно, что класс будет шаблонный, также очевидно, что у него будет один параметр шаблона — сигнатура (тип) вызываемой функции. Общая реализация шаблона отсутствует, вся работа будет происходить в частичной специализации шаблона. Частичная специализация нужна для того чтобы мы могли использовать типы аргументов и возвращаемого значения из нашей сигнатуры.
Сама реализация:
template <typename UnusedType>
class function;
template <typename ReturnType, typename ... ArgumentTypes>
class function <ReturnType (ArgumentTypes ...)> {
public:
function() : mInvoker() {}
template <typename FunctionT>
function(FunctionT f) : mInvoker(new free_function_holder<FunctionT>(f)) {}
ReturnType operator ()(ArgumentTypes ... args) {
return mInvoker->invoke(args ...);
}
private:
class function_holder_base {
public:
function_holder_base() {}
virtual ~function_holder_base() {}
virtual ReturnType invoke(ArgumentTypes ... args) = 0;
};
typedef std::auto_ptr<function_holder_base> invoker_t;
template <typename FunctionT>
class free_function_holder : public function_holder_base {
public:
free_function_holder(FunctionT func) : function_holder_base(), mFunction(func) {}
virtual ReturnType invoke(ArgumentTypes ... args) {
return mFunction(args ...);
}
private:
FunctionT mFunction;
};
invoker_t mInvoker;
};
Класс function определяет оператор () соответствующий сигнатуре функции и передает управление методу invoke у класса function_holder_base. Этот класс имеет виртуальную функцию invoke, которая тоже совпадает с указанной сигнатурой (за исключением неявного параметра this).
Также класс function имеет шаблонный конструктор, который принимает один аргумент, в этом конструкторе создается наследник templated_function_holder класса function_holder_base. Этот наследник является шаблонным классом — он сохраняет в себе переданный аргумент (обычно это функтор или указатель на функцию). В нем также определяется метод invoke, который вызывает сохраненный функтор с заданными аргументами.
Здесь необходимо отметить несколько особенностей шаблонов в C++:
- Тип возвращаемого значения может быть любой (в том числе и void), то есть конструкция return mFunction(args ...); валидна даже в том случае, когда возвращаемое значение void. Это сделано специально для шаблонного метапрограммирования, чтобы не плодить специализации для типа void.
- Аналогичным образом работают и variadic templates если количество входных аргументов равно 0 (функция без параметров).
- Мы можем написать шаблонный класс, который является наследником какого-то базового класса (причем необязательно шаблонного) — на этом стоит весь паттерн Type erasure
В принципе, мы получили работоспособный аналог std::function и boost::function, мы вполне можем писать следующий код:
int func2(const int * x, int y) {
return (*x) + y;
}
///...
typedef function<int (const int * , int)> int_function_with_two_args_t;
int_function_with_two_args_t f2(func2);
int x = 10;
cout << "calling function with signature int (const int * , int): " << f2(&x, 20) << endl;Переходим к улучшениям нашего класса:
Копируем поведение обычного указателя на функцию — оператор присваивания и конструктор копирования
Для того чтобы скопировать или присвоить объект мы должны уметь копировать (клонировать) указатель на базовый класс function_holder_base. Для этого расширим интерфейс этого класса следующим образом:
class function_holder_base {
public:
function_holder_base() {}
virtual ~function_holder_base(){}
virtual ReturnType invoke(ArgumentTypes ... args) = 0;
virtual std::auto_ptr<function_holder_base> clone() = 0;
private:
function_holder_base(const function_holder_base & );
void operator = (const function_holder_base &);
};Делаем наш класс некопируемым (декларируем соответствующие оператор и конструктор в private секции), и добявляем метод clone, чтобы наследники сами определяли правильную стратегию клонирования.
Также, в класс function добавляются операторы присваивания и конструктор копирования:
function(const function & other)
: mInvoker(other.mInvoker->clone()) {}
function & operator = (const function & other) {
mInvoker = other.mInvoker->clone();
}Здесь мы используем auto_ptr и его разрушающее присваивание.
Осталось написать реализацию метода clone в наследнике — free_function_holder:
typedef free_function_holder<FunctionT> self_type;
virtual invoker_t clone() {
return invoker_t(new self_type(mFunction));
}Вот собственно и все, теперь наш класс ведет себя как обычный указатель на функцию, и мы можем делать так:
int func1() {
return 0;
}
///...
typedef function<int (void)> int_function_t;
int_function_t f1(func1);
cout << "calling function with signature int (void): " << f1() << endl;
int_function_t f2;
f2 = f1;
cout << "calling function after assignment operator with signature int (void): " << f2() << endl;
int_function_t f3(f2);
cout << "calling function after copying ctor with signature int (void): " << f3() << endl;Переходим к заключительной части:
Добавляем поддержку указателей на функции-члены
Поддержка указателей на методы у меня получилась довольно ограниченная: можно передавать объект к которому применяется указатель на метод только по значению (а хотелось бы еще по ссылке (const и не const) и по указателю (const и не const)), но в принципе для примера этого будет достаточно.
При использовании boost (std) и нашей реализации function придерживаемся правила, что первым аргументом должен идти объект, к которому применяется указатель на метод, соответственно аргументы теперь делятся на два вида: сам объект, и аргументы метода. Соответственно, у нас есть гарантия, что количество аргументов строго больше 0, этим мы и воспользуемся далее:
template <typename FunctionType, typename ClassType, typename ... RestArgumentTypes>
class member_function_holder : public function_holder_base
{
public:
typedef FunctionType ClassType::* member_function_signature_t;
member_function_holder(member_function_signature_t f) : mFunction(f){}
virtual ReturnType invoke(ClassType obj, RestArgumentTypes ... restArgs) {
return (obj.*mFunction)(restArgs ...);
}
virtual invoker_t clone() {
return invoker_t(new member_function_holder(mFunction));
}
private:
member_function_signature_t mFunction;
};Реализация конструктора, который принимает указатель на метод тривиальна:
template <typename FunctionType, typename ClassType>
function(FunctionType ClassType::* f)
: mInvoker(new member_function_holder<FunctionType, ArgumentTypes ...>(f))
{}Мы сделали еще одного наследника function_holder_base специально для указателей на методы. Здесь используется особенность variadic templates: переменное количество типов (которое задается троеточием) можно расщепить на фиксированную часть, и остаток переменной длины (в котором количество типов меньше на размер фиксированной части). В конструкторе мы передаем в параметры шаблона фиксированную часть состоящую из одного типа — сигнатура функции, и произвольную часть — все остальное (это типы всех аргументов), а в реализации member_function_holder мы требуем, чтобы фиксированная часть состояла из двух элементов — сигнатура функции, класс, в котором находится наш метод, и аргументы непосредственно для вызова (здесь мы как раз используем указанную выше гарантию, что количество всех аргументов строго больше 0). Таким образом, мы сохраняем указатель на метод в конструкторе, и вызываем его в реализации метода invoke.
Отдельно хочется сказать про крайне неудобный и неинтуитивный способ декларирования типа «указатель на метод» и про способ вызова такого метода. По этому поводу в C++ FAQ есть предупреждение, о том как минимизировать количество головной боли при работе с указателями на методы (я полчаса гуглил, как записать правильно это выражение)
Вот и пример использования:
struct Foo {
int smth(int x) {
return x + 1;
}
};
///...
typedef function<int (Foo, int)> member_function_t;
member_function_t f1 = &Foo::smth;
Foo foo;
cout << "calling member function with signature int (int): " << f1(foo, 5) << endl;
Заключение
Благодаря поддержке variadic templates реализация function получилась довольно лаконичной, в том же boost из-за необходимости поддерживать старые компиляторы (в которых нет variadic templates) данный функционал реализован с помощью boost.preprocessor (и имеет ограничение на количество аргументов — по умолчанию 10, можно поменять, определив соответствующий define: BOOST_FUNCTION_MAX_ARGS). Грубо говоря, реализация сделана для функций с одним аргументом, а потом «клонирована» на большее количество аргументов с помощью препроцессорной магии.
Полностью пример находится здесь
Автор: prograholic
