在 std::函数上递归应用 std::bind 的问题

首先，停止使用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);
}

接下来，仅当必须执行以下操作时，才键入擦除：

// `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;}传递为第三个参数。

如果您不想更改，请将[](auto&&x){return x;}传递为第 3 个参数。

这些代码都没有编译，因此可能存在拼写错误。 我也担心 C++14 返回类型扣除的递归，这有时会变得棘手。

如果你真的需要使用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)>());
}

演示。 make_integer_sequence和朋友是C++14，但可以在C++11中轻松实现。

如果您准备放弃std::bind(在我看来，对于 C++11 之前的部分应用程序来说，这确实是一个有点笨拙的解决方法(，这可以非常简洁地编写：

#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 进行测试。也在 ideone 上。

你不需要递归地使用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.在他的回答中指出的那样std::make_index_sequence这是一个C++14功能，但它可以在C++11中实现。