给定函数f(x, y, z)，我们可以将x绑定为0，获取函数g(y, z) == f(0, y, z)。我们可以继续这样做并获得h() = f(0, 1, 2)。
在C ++语法中
#include <functional>
#include <iostream>
void foo(int a, long b, short c)
{
std::cout << a << b << c << std::endl;
}
int main()
{
std::function<void(int, long, short)> bar1 = foo;
std::function<void(long, short)> bar2 = std::bind(bar1, 0, std::placeholders::_1, std::placeholders::_2);
std::function<void(short)> bar3 = std::bind(bar2, 1, std::placeholders::_1);
std::function<void()> bar4 = std::bind(bar3, 2);
bar4(); // prints "012"
return 0;
}
到目前为止一切顺利。
现在说我想做同样的事情 - 绑定函数的第一个参数，返回新函数并重复此过程直到所有参数都被绑定 - 但是将其推广到不仅仅用3的函数工作如上面的C ++示例中的参数，但是具有未知*参数数量的函数。
*在C ++中存在可变参数，在C ++ 11中存在可变参数模板。我在这里指的是可变参数模板。
基本上，我希望能够做的是编写一个接受任何std::function的函数，并递归地将第一个参数绑定到某个值，直到所有参数都被绑定并且可以调用该函数。
为简单起见，我们假设std::function表示一个函数接受任何integral个参数并返回void。
这段代码可以考虑为前一代码的概括
#include <functional>
#include <iostream>
// terminating case of recursion
void apply(std::function<void()> fun, int i)
{
fun();
}
template<class Head, class... Tail>
void apply(std::function<void(Head, Tail...)> f, int i)
{
std::function<void(Tail...)> g = std::bind(f, i);
apply<Tail...>(g, ++i);
}
void foo(int a, long b, short c)
{
std::cout << a << b << c << std::endl;
}
int main()
{
std::function<void(int, long, short)> bar1 = foo;
apply<int, long, short>(bar1, 0);
return 0;
}
这段代码很棒。这正是我想要的。它没有编译。
main.cpp: In instantiation of 'void apply(std::function<void(Head, Tail ...)>, int) [with Head = int; Tail = {long int, short int}]':
main.cpp:24:40: required from here
main.cpp:12:56: error: conversion from 'std::_Bind_helper<false, std::function<void(int, long int, short int)>&, int&>::type {aka std::_Bind<std::function<void(int, long int, short int)>(int)>}' to non-scalar type 'std::function<void(long int, short int)>' requested
std::function<void(Tail...)> g = std::bind(f, i);
^
问题在于，您不能在std::placeholders这样的电话中忽略std::bind。它们是必需的，std::bind中占位符的数量应该与函数中非绑定参数的数量相匹配。
如果我们更改行
std::function<void(Tail...)> g = std::bind(f, i);
到
std::function<void(Tail...)> g = std::bind(f, i, std::placeholders::_1, std::placeholders::_2);
我们看到它成功通过了第一次apply()调用，但在第二次传递时卡住了，因为在第二次传递期间g只需要一个占位符，而我们仍然有两个占位符std::bind。
main.cpp: In instantiation of 'void apply(std::function<void(Head, Tail ...)>, int) [with Head = long int; Tail = {short int}]':
main.cpp:13:30: required from 'void apply(std::function<void(Head, Tail ...)>, int) [with Head = int; Tail = {long int, short int}]'
main.cpp:24:40: required from here
main.cpp:12:102: error: conversion from 'std::_Bind_helper<false, std::function<void(long int, short int)>&, int&, const std::_Placeholder<1>&, const std::_Placeholder<2>&>::type {aka std::_Bind<std::function<void(long int, short int)>(int, std::_Placeholder<1>, std::_Placeholder<2>)>}' to non-scalar type 'std::function<void(short int)>' requested
std::function<void(Tail...)> g = std::bind(f, i, std::placeholders::_1, std::placeholders::_2);
^
有一种方法可以使用常规的非可变参数模板来解决这个问题，但是它引入了std::function个参数的限制。例如，仅当std::function具有3个或更少的参数
（替换前面代码中的apply函数）
// terminating case
void apply(std::function<void()> fun, int i)
{
fun();
}
template<class T0>
void apply(std::function<void(T0)> f, int i)
{
std::function<void()> g = std::bind(f, i);
apply(g, ++i);
}
template<class T0, class T1>
void apply(std::function<void(T0, T1)> f, int i)
{
std::function<void(T1)> g = std::bind(f, i, std::placeholders::_1);
apply<T1>(g, ++i);
}
template<class T0, class T1, class T2>
void apply(std::function<void(T0, T1, T2)> f, int i)
{
std::function<void(T1, T2)> g = std::bind(f, i, std::placeholders::_1, std::placeholders::_2);
apply<T1, T2>(g, ++i);
}
但该代码的问题在于我必须定义一个新的apply函数来支持带有4个参数的std::function，然后用5个参数定义，6依旧等等。更不用说我的目标是不对参数的数量有任何硬编码限制。所以这是不可接受的。我不希望它有限制。
我需要找到一种方法来使可变参数模板代码（第二个代码段）起作用。
如果只有std::bind不需要指定占位符 - 一切都会有效，但是当std::bind当前有效时，我们需要找到一些方法来指定合适的占位符数。
知道我们可以找到使用C ++ 11 sizeof...
sizeof...(Tail)
但是我无法从这个事实中获得任何有价值的东西。
答案 0 :(得分：4)
首先，除非您绝对需要，否则请停止使用bind。
// terminating case of recursion
void apply(std::function<void()> fun, int i) {
fun();
}
// recursive case:
template<class Head, class... Tail>
void apply(std::function<void(Head, Tail...)> f, int i) {
// create a one-shot lambda that binds the first argument to `i`:
auto g = [&](Tail&&...tail) // by universal ref trick, bit fancy
{ return std::move(f)(std::move(i), std::forward<Tail>(tail)...);};
// recurse:
apply<Tail...>(g, ++i);
}
接下来，如果必须，只需键入erase：
// `std::resukt_of` has a design flaw. `invoke` fixes it:
template<class Sig,class=void>struct invoke{};
template<class Sig>using invoke_t=typename invoke<Sig>::type;
// converts any type to void. Useful for sfinae, and may be in C++17:
template<class>struct voider{using type=void;};
template<class T>using void_t=typename voider<T>::type;
// implementation of invoke, returns type of calling instance of F
// with Args...
template<class F,class...Args>
struct invoke<F(Args...),
void_t<decltype(std::declval<F>()(std::declval<Args>()...))>
>{
using type=decltype(std::declval<F>()(std::declval<Args>()...));
};
// tells you if F(Args...) is a valid expression:
template<class Sig,class=void>struct can_invoke:std::false_type{};
template<class Sig>
struct can_invoke<Sig,void_t<invoke_t<Sig>>>
:std::true_type{};
现在我们有一些机器，一个基本案例：
// if f() is a valid expression, terminate:
template<class F, class T, class I,
class=std::enable_if_t<can_invoke<F()>{}>
>
auto apply(F&& f, T&& t, I&&i)->invoke_t<F()>
{
return std::forward<F>(f)();
}
表示“如果我们可以调用，只需调用f。
接下来，递归案例。它依赖于C ++ 14返回类型演绎：
// if not, build lambda that binds first arg to t, then recurses
// with i(t):
template<class F, class T, class I,
class=std::enable_if_t<!can_invoke<F()>{}, int>>
>
auto apply(F&& f, T&& t, I&&i)
{
// variardic auto lambda, C++14 feature, with sfinae support
// only valid to call once, which is fine, and cannot leave local
// scope:
auto g=[&](auto&&...ts) // takes any number of params
-> invoke_t< F( T, decltype(ts)... ) > // sfinae
{
return std::forward<F>(f)(std::forward<T>(t), decltype(ts)(ts)...);
};
// recurse:
return apply(std::move(g), i(t), std::forward<I>(i));
}
如果您想要增加，请将[](auto&&x){return x+1;}作为第3个参数传递。
如果您不想更改，请将[](auto&&x){return x;}作为第3个参数传递。
此代码均未编译，因此可能存在拼写错误。我也担心使用C ++ 14返回类型演绎的递归递归，有时会变得棘手。
答案 1 :(得分：2)
如果您真的必须使用bind，则可以通过专门化std::is_placeholder来定义自己的占位符类型：
template<int N>
struct my_placeholder { static my_placeholder ph; };
template<int N>
my_placeholder<N> my_placeholder<N>::ph;
namespace std {
template<int N>
struct is_placeholder<::my_placeholder<N>> : std::integral_constant<int, N> { };
}
这个有用的原因是它允许你在编译时将一个整数映射到占位符，你可以使用integer_sequence技巧：
void apply(std::function<void()> fun, int i)
{
fun();
}
template<class T, class... Ts>
void apply(std::function<void(T, Ts...)> f, int i);
template<class T, class... Ts, int... Is>
void apply(std::function<void(T, Ts...)> f, int i, std::integer_sequence<int, Is...>)
{
std::function<void(Ts...)> g = std::bind(f, i, my_placeholder<Is + 1>::ph...);
apply(g, ++i);
}
template<class T, class... Ts>
void apply(std::function<void(T, Ts...)> f, int i) {
apply(f, i, std::make_integer_sequence<int, sizeof...(Ts)>());
}
Demo。 make_integer_sequence和朋友是C ++ 14，但可以在C ++ 11中轻松实现。
答案 2 :(得分：1)
如果您准备放弃std::bind（在我看来，这对于C ++ 11之前的部分应用程序来说确实是一个hacky变通方法），这可以写得非常简洁：
#include <functional>
#include <iostream>
// End recursion if no more arguments
void apply(std::function<void()> f, int) {
f();
}
template <typename Head, typename ...Tail>
void apply(std::function<void(Head, Tail...)> f, int i=0) {
auto g = [=](Tail&& ...args){
f(i, std::forward<Tail>(args)...);
};
apply(std::function<void(Tail...)>{g}, ++i);
}
void foo(int a, int b, int c, int d) {
std::cout << a << b << c << d << "\n";
}
int main() {
auto f = std::function<void(int,int,int,int)>(foo);
apply(f);
}
在C ++ 11模式下测试使用clang 3.4和g ++ 4.8.2。还on ideone。
答案 3 :(得分：0)
你不需要递归地使用std::bind来调用一些带有参数元组的函数，这些参数值可以使用参数索引进行评估：
#include <functional>
#include <utility>
template <typename... Types, std::size_t... indexes, typename Functor>
void apply(std::function<void(Types...)> f, std::index_sequence<indexes...>, Functor&& functor)
{
f(static_cast<Types>(std::forward<Functor>(functor)(indexes))...);
}
template <typename... Types, typename Functor>
void apply(std::function<void(Types...)> f, Functor&& functor)
{
apply(f, std::make_index_sequence<sizeof...(Types)>{}, std::forward<Functor>(functor));
}
使用示例：
void foo(int a, long b, short c)
{
std::cout << a << b << c << std::endl;
}
// ...
std::function<void(int, long, short)> bar = foo;
apply(bar, [](std::size_t index){ return (int)index; });
正如@T.C.所提到的in his answer std::make_index_sequence是C ++ 14功能，但是it can be implemented in C++11。