函数参数的部分绑定 [英] Partial Binding of Function Arguments
问题描述
有没有方法可以部分地绑定可调用对象(例如函数)的第一个/最后一个参数,而不明确指定其余的参数?
Is there a way to partially bind the first/last n arguments of a callable object (e.g. function) without explicitly specifying the rest of the arguments?
std :: bind()
似乎要求全部绑定,那些要留下的应绑定到 std :: placeholders :: _ 1
, _2
, _3
等。
std::bind()
seems to require that all the arguments are be bound, those that are to be left should be bound to std::placeholders::_1
,_2
,_3
etc.
可以写一个 bind_first()
/ bind_last()
用于从第一个/最后一个参数开始的部分绑定,并自动在其原始位置以原始顺序插入任何剩余未绑定参数的占位符? / p>
Is it possible to write a bind_first()
/bind_last()
for partial binding starting from the first/last argument and that automagically inserts the placeholders for any remaining unbound arguments in their original order in their the original position?
推荐答案
Boost或标准库 bind
你可以自己写这样的小工具,如果你有一个下雨的晚上填补;下面是一个纯函数的尾随参数的例子:
Neither Boost nor the standard library bind
fill in the blanks automatically. You could write such a gadget yourself if you have a rainy evening to fill; here's an example for trailing arguments of a plain function only:
#include <tuple>
#include <type_traits>
#include <utility>
template <typename F, typename ...Args> struct trailing_binder;
template <typename R, typename ...Frgs, typename ...Args>
struct trailing_binder<R(Frgs...), Args...>
{
template <typename ...Brgs>
trailing_binder(R (*f)(Frgs...), Brgs &&... brgs)
: the_function(f)
, the_args(std::forward<Brgs>(brgs)...)
{ }
template <unsigned int ...I> struct intlist {};
template <typename ...Brgs>
typename std::enable_if<sizeof...(Brgs) + sizeof...(Args) == sizeof...(Frgs), R>::type
operator()(Brgs &&... brgs)
{
return unwrap(std::integral_constant<bool, 0 == sizeof...(Args)>(),
intlist<>(),
std::forward<Brgs>(brgs)...);
}
private:
template <unsigned int ...I, typename ...Brgs>
R unwrap(std::false_type, intlist<I...>, Brgs &&... brgs)
{
return unwrap(std::integral_constant<bool, sizeof...(I) + 1 == sizeof...(Args)>(),
intlist<I..., sizeof...(I)>(),
std::forward<Brgs>(brgs)...);
}
template <unsigned int ...I, typename ...Brgs>
R unwrap(std::true_type, intlist<I...>, Brgs &&... brgs)
{
return the_function(std::get<I>(the_args)..., std::forward<Brgs>(brgs)...);
}
R (*the_function)(Frgs...);
std::tuple<Args...> the_args;
};
template <typename R, typename ...Args, typename ...Frgs>
trailing_binder<R(Frgs...), Args...> trailing_bind(R (*f)(Frgs...), Args &&... args)
{
return trailing_binder<R(Frgs...), typename std::decay<Args>::type...>(f, std::forward<Args>(args)...);
}
用法:
int f(int a, int b, int c, int d) { return a + b + c + d; }
int main()
{
auto b = trailing_bind(f, 1);
return b(3, 8, 13);
}
这篇关于函数参数的部分绑定的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!