boost :: bind () — как вещь, но для вызовов функций

Question

boost :: bind () — как вещь, но для вызовов функций

Дано boost::bind или std:: эквиваленты, я могу сделать это:

int f(int a, int b)
{
return a + b;
}

auto f_two = boost::bind(f, 1, 1);

Чтобы f_two() вернет 2, эффективно вызывая промежуточную функцию, которая вызывает f(1, 1) с помощью любого механизма реализации, возможно, что-то вроде:

double f_two_caller()
{
return f(stored_arg_1, stored_arg_2);
}

Тем не менее, мой вариант использования заключается в том, что я хотел бы связать префиксную функцию, чтобы вместо этого я мог сказать:

auto f_print = boost::bind(printf, "Hello, world!\n");
auto f_print_and_two = boost::bind_with_prefix(f, f_print, 1, 1);

Так f_print_and_two() эффективно выполняет:

double f_print_and_two_caller()
{
f_print(f_print.stored_arg_1);
return f(stored_arg_1, stored_arg_2);
}

Я уверен, что есть подходящее название для этой техники, которую я мог бы использовать, чтобы найти решение, но я не могу думать об этом сейчас …

0

boost c++c++11 function-binding

Решение

Другие решения

Я думаю из вашего описания, это то, что вы ищете:

#include <cstdio>
#include <tuple>
#include <utility>
#include <functional>

template<class F, class PrefixF, class...Args>
auto wrap_call_prefix(F&& f, PrefixF&& pf, Args&&...args)
{
return [f = std::forward<F>(f),
pf = std::forward<PrefixF>(pf),
args = std::make_tuple(std::forward<Args>(args)...)]
{
pf();
return std::apply(f, args);
};
}

int main()
{
auto add = [](auto x, auto y) { return x + y; };
auto f_print = std::bind(printf, "Hello, world!\n");

auto f_print_and_two_caller = wrap_call_prefix(add, f_print, 1, 2);

printf("%d\n", f_print_and_two_caller());
}

std::apply это с ++ 17.

1

На твоем месте я бы не копировал bind функциональность и просто пойти на что-то вроде этого, что довольно просто:

template<class Pre, class U>
class with_prefix_class{
public:
template<class V, class W>
with_prefix_class(V &&v, W &&w) : pre_(std::forward<V>(v)), func_(std::forward<W>(w)){}

decltype(std::declval<U>()()) operator()(){
pre_();
return func_();
}

private:
Pre pre_;
U func_;
};

int f(int a, int b)
{
return a + b;
}

template<class Pre, class U>
with_prefix_class<Pre, U> with_prefix(Pre &&pre, U &&u){
return with_prefix_class<Pre, U>(std::forward<Pre>(pre), std::forward<U>(u));
}

int main(int argc, char* argv[]) {
auto a = with_prefix([](){}, std::bind(f, 5, 3));
a();
}

0

Источник

Accepted Answer

template<class First, class Second>
struct compose_t {
First first;
Second second;
template<class...Args>
auto operator()(Args&&...args)
-> decltype( std::declval<Second&>()( std::declval<First&>()( std::declval<Args>()... ) ) )
{ return second(first( std::forward<Args>(args)... ) ); }
};
template<class First, class Second>
compose_t<typename std::decay<First>::type, typename std::decay<Second>::type>
compose( First&& first, Second&& second ){ return {std::forward<First>(first), std::forward<Second>(second)}; }

это функциональная композиция.

auto f_print = std::bind(printf, "Hello, world!\n");

auto f_print_and_two = std::bind( compose(f, f_print), 1, 1 );

int main() {
f_print_and_two();
}

а также сделанный.

Обратите внимание, что состав функции может быть связан. Вы даже можете написать variardic compose функция основана на выше.

1