[Из песочницы] Наивная реализация std::bind(boost::bind)
Наверное, трудно найти такого программиста на C++, который никогда не применял в своем коде boost: bind (с выходом c++11 std: bind). Bind — шаблонная функция, возвращающая обёртку над callable-объектом (т.е. объектом, который можно вызвать, передав ему необходимое число аргументов в круглых скобочках). Bind позволяет изменить сигнатуру вызова такого объекта, сократив число входных аргументов или поменяв какие-то из них местами. Кому интересно, как это может быть реализовано с использованием C++11, прошу под кат.
Примеры использования
В данном примере std: bind берет за основу указатель на функцию sum и в качестве её аргумента lhs использует 3, а в качестве rhs — второй аргумент из переданных на вход callable-объекта f_sum. Таким образом результатом вызова f_sum будет 10. Все очень просто. Понятно, что подобным же образом std: bind можно использовать и с функциями-членами. Отличие будет только в том, что в этом случае в качестве первого аргумента в конструктор callable-объекта необходимо передать объект соответствующего класса, у которого будет вызвана функция-член.
Собственно реализация
Здесь binder — шаблонный класс, у которого определен оператор круглые скобки. Помимо этого задача binder-а хранить в себе все переданные ему на вход аргументы. Для простоты реализации делать это он будет по значению. Отметим, что std: bind хранит аргументы также по значению, если его не попросить об ином.
Здесь naive: args_list очень отдаленно напоминает std: tuple. Его задача хранить произвольное количество аргументов произвольных типов. Понятно, что стандартные контейнеры наподобие std: vector, list, deque, … для этого не годятся. Ниже приводится реализация naive: args_list.
Дополнительный шаблонный параметр целого типа структуры naive: arg нужен для того, чтобы различать несколько аргументов с одинаковыми типами (типы одинаковые, индексы — разные). Кстати, аргументы в binder при вызове его оператора «круглые скобки» передаются с использованием args_list (правда, там имеется небольшая хитрость на случай пустого списка).
либо была передана функция-член класса и тогда вызов будет таким (member_function_invoker):
Какой тип «вызывателя» использовать определяем на этапе конструирования биндера.
Теперь самое интересное. Как же реализовать оператор «круглые скобки» у биндера. Сначала посмотрим на код:
Функция get_arg просто возвращает I-й элемент из списка args_list, полученного при конструировании naive: binder.
Теперь рассмотрим take_arg. Имеется две перегрузки этой функции, одна из которых необходима для работы с плейсхолдерами, другая — для всех остальных случаев. Например, если при создании биндера в его конструктор был передан std: placeholders::_N, то при вызове оператора круглые скобки биндер подставит вместо std: placeholders::_N N-ый аргумент переданный ему на вход. Во всех остальных случаях биндер проигнорирует аргументы, переданные в оператор «круглые скобки» и подставит соответствующие значения, полученные им в конструкторе.
Вот собственно и всё. Ниже даны примеры использования naive: bind.
Понятно, что naive: bind является наивной (см. название поста) реализацией std: bind и не претендует на включение в стандарт. Многие вещи можно было реализовать по-другому: например, вместо args_list использовать std: tuple, по-иному реализовать invoker (он же в тексте «вызыватель») и т.п. Целью статьи было попытаться разобраться в том, как устроен std: bind под капотом, посмотреть на его простейшую реализацию. Надеюсь, что это получилось. Спасибо за внимание!
Примеры использования
Вот простейший (надуманный) пример использования bind-a:
int sum( int lhs, int rhs )
{
return lhs + rhs;
}
auto f_sum = std::bind( sum, 3, std::placeholders::_2 );
f_sum( 5, 7 ); // f_sum вернет 10
В данном примере std: bind берет за основу указатель на функцию sum и в качестве её аргумента lhs использует 3, а в качестве rhs — второй аргумент из переданных на вход callable-объекта f_sum. Таким образом результатом вызова f_sum будет 10. Все очень просто. Понятно, что подобным же образом std: bind можно использовать и с функциями-членами. Отличие будет только в том, что в этом случае в качестве первого аргумента в конструктор callable-объекта необходимо передать объект соответствующего класса, у которого будет вызвана функция-член.
struct A
{
void Print() const
{
std::cout << "A::Print()" << std::endl;
}
};
A a;
auto f = std::bind(&A::Print, a);
f(); // "напечатает" A::Print()Собственно реализация
Итак, std: bind — шаблонная функция, которая принимает на вход указатель на callable-объект и аргументы, которые могут быть константами, переменными или плейсхолдерами (placeholder). В рамках нового (с++11) стандарта это может быть записано так:
namespace naive
{
template
binder bind( Func const & func, BinderArgs &&... args )
{
return binder( func, std::forward( args )... );
}
} Здесь binder — шаблонный класс, у которого определен оператор круглые скобки. Помимо этого задача binder-а хранить в себе все переданные ему на вход аргументы. Для простоты реализации делать это он будет по значению. Отметим, что std: bind хранит аргументы также по значению, если его не попросить об ином.
// ...
template
struct binder
{
binder( Func const & func, BinderArgs &&... binderArgs )
: m_func{ func}
, m_args{ std::forward(binderArgs)... }
{}
template
void operator()( Args &&... args ) const
{
// ...
}
// ...
private:
invoker_t m_invoker;
Func m_func;
args_list m_args;
};
// ... Здесь naive: args_list очень отдаленно напоминает std: tuple. Его задача хранить произвольное количество аргументов произвольных типов. Понятно, что стандартные контейнеры наподобие std: vector, list, deque, … для этого не годятся. Ниже приводится реализация naive: args_list.
// arg далее используется в качестве базового класса для args_list.
// дополнительный шаблонный параметр std::size_t нужен, чтобы имелась возможность различать
// аргументы с одинаковым типом
template
struct arg
{
explicit arg( T val ) : value( val ) {}
T const value;
};
template
struct args_list_impl;
template
struct args_list_impl, Args...> : arg...
{
template
args_list_impl( OtherArgs &&... args ) : arg( std::forward(args) )... {}
};
template
struct args_list : args_list_impl< typename make_indices< sizeof...( Args )>::type, Args... >
{
using base_t = args_list_impl< typename make_indices< sizeof...( Args ) >::type, Args... >;
template
args_list( OtherArgs &&... args ) : base_t( std::forward(args)... ) {}
}; Дополнительный шаблонный параметр целого типа структуры naive: arg нужен для того, чтобы различать несколько аргументов с одинаковыми типами (типы одинаковые, индексы — разные). Кстати, аргументы в binder при вызове его оператора «круглые скобки» передаются с использованием args_list (правда, там имеется небольшая хитрость на случай пустого списка).
Движемся далее. В теле класса naive: binder определен оператор круглые скобки, который перенаправляет вызов в соответствующий invoker («вызыватель») в зависимости от переданного на вход callable-объекта. Здесь возможны два варианта: либо была передана «обычная» функция и тогда ее нужно вызвать так (free_function_invoker):
template
void invoke( Func const & func, Args &&... args ) const
{
return func( std::forward(args)... );
} либо была передана функция-член класса и тогда вызов будет таким (member_function_invoker):
template
void invoke( Func const & func, ObjType && obj, Args &&... args ) const
{
return (obj.*func)( std::forward(args)... );
}
Какой тип «вызывателя» использовать определяем на этапе конструирования биндера.
using invoker_t = conditional_t< std::is_member_function_pointer::value, member_function_invoker, free_function_invoker >; Теперь самое интересное. Как же реализовать оператор «круглые скобки» у биндера. Сначала посмотрим на код:
template
struct binder
{
// ...
template
void operator()( Args &&... args ) const
{
// need check: sizeof...(Args) should not be less than max placeholder value
call_function( make_indices< sizeof...(BinderArgs) >{}, std::forward(args)... );
}
private:
template< std::size_t... Indices, typename... Args >
void call_function( indices const &, Args &&... args ) const
{
struct empty_list
{
empty_list( Args &&... args ) {}
};
using args_t = conditional_t< sizeof...(Args) == 0, empty_list, args_list >;
args_t const argsList{ std::forward(args)... };
m_invoker.invoke( m_func, take_argument( get_arg( m_args ), argsList )... );
}
// ...
}; Функция get_arg
template
struct type_at_index
{
using type = typename type_at_index::type;
};
template
struct type_at_index<0, Head, Tail...>
{
using type = Head;
};
template
using type_at_index_t = typename type_at_index::type;
template
type_at_index_t get_arg( args_list const & args )
{
arg< I, type_at_index_t > const & argument = args;
return argument.value;
};
Теперь рассмотрим take_arg. Имеется две перегрузки этой функции, одна из которых необходима для работы с плейсхолдерами, другая — для всех остальных случаев. Например, если при создании биндера в его конструктор был передан std: placeholders::_N, то при вызове оператора круглые скобки биндер подставит вместо std: placeholders::_N N-ый аргумент переданный ему на вход. Во всех остальных случаях биндер проигнорирует аргументы, переданные в оператор «круглые скобки» и подставит соответствующие значения, полученные им в конструкторе.
template
T take_argument( T const & arg, S const & args )
{
return arg;
}
template::value,
typename = typename std::enable_if< I != 0 >::type >
type_at_index_t take_argument( T const & ph, args_list const & args )
{
return get_arg< I-1, Args... >( args );
}
Вот собственно и всё. Ниже даны примеры использования naive: bind.
Примеры использования
#include "binder.hpp"
#include
#include
void Print( std::string const & msg )
{
std::cout << "Print(): " << msg << std::endl;
}
struct A
{
void Print( std::string const & msg )
{
std::cout << "A::Print(): " << msg << std::endl;
}
};
int main()
{
std::string const hello {"hello"};
auto f = naive::bind( &Print, hello );
auto f2 = naive::bind( &Print, std::placeholders::_1 );
f();
f2( hello );
A a;
auto f3 = naive::bind( &A::Print, std::placeholders::_2, std::placeholders::_1 );
auto f4 = naive::bind( &A::Print, std::placeholders::_1, hello );
auto f5 = naive::bind( &A::Print, a, std::placeholders::_1 );
auto f6 = naive::bind( &A::Print, a, hello );
f3( hello, a );
f4( a );
f5( hello );
f6();
return 0;
}
Понятно, что naive: bind является наивной (см. название поста) реализацией std: bind и не претендует на включение в стандарт. Многие вещи можно было реализовать по-другому: например, вместо args_list использовать std: tuple, по-иному реализовать invoker (он же в тексте «вызыватель») и т.п. Целью статьи было попытаться разобраться в том, как устроен std: bind под капотом, посмотреть на его простейшую реализацию. Надеюсь, что это получилось. Спасибо за внимание!
» Все исходники можно найти на Github
» Компилировалось всё g++-6.2
