在元组上泛化for_each以接受可变数量的参数

我不确定这是你所期望的，但我会把它贴出来-也许有人会发现它有帮助。

namespace std {
    template<int I, class Tuple, typename F> struct for_each_impl {
        static void for_each(const Tuple& t, F f) {
            for_each_impl<I - 1, Tuple, F>::for_each(t, f);
            f(get<I>(t));
        }
    };
    template<class Tuple, typename F> struct for_each_impl<0, Tuple, F> {
        static void for_each(const Tuple& t, F f) {
            f(get<0>(t));
        }
    };
    template<class Tuple, typename F>
    F for_each(const Tuple& t, F f) {
        for_each_impl<tuple_size<Tuple>::value - 1, Tuple, F>::for_each(t, f);
        return f;
    }
}

函子:

struct call_tuple_item {
    template<typename T>
    void operator()(T a) {
        std::cout << "call_tuple_item: " << a << std::endl;
    }
};

主要功能:

std::tuple<float, const char*> t1(3.14, "helloworld");
std::for_each(t1, call_tuple_item());

您可以在这里查看我的答案以获取扩展元组的提示

如何将元组扩展为可变模板函数的参数?

请参阅下面我将使用的map(UnaryFunction, Tuple&&...)实现，以及我一直在试图让它完全工作的代码(for_aux, last等)。

#include <array>
#include <iostream>
#include <tuple>
namespace detail {
  struct static_ {
  private:
    static_() = delete;
    static_(const static_&) = delete;
    static_& operator=(const static_&) = delete;
  };
  template <unsigned... Args>
  struct max;
  template <unsigned Head, unsigned... Tail>
  struct max<Head, Tail...>: private static_ {
    static const unsigned value = Head > max<Tail...>::value
      ? Head
      : max<Tail...>::value;
  };
  template <>
  struct max<>: private static_ {
    static const unsigned value = 0;
  };
  template <unsigned... Args>
  struct min;
  template <unsigned Head, unsigned... Tail>
  struct min<Head, Tail...>: private static_ {
    static const unsigned value = Head < min<Tail...>::value
      ? Head
      : min<Tail...>::value;
  };
  template <>
  struct min<>: private static_ {
    static const unsigned value = 0;
  };
  template <typename... Args>
  struct for_aux;
  template <typename A, typename B>
  struct for_aux<A, B>: private static_ {
    static
    void call(A&& a, B b) {
      b(std::forward(a));
    }
  };
  template <typename A, typename B, typename C>
  struct for_aux<A, B, C>: private static_ {
    static
    void call(A&& a, B&& b, C c) {
      c(std::forward(a), std::forward(b));
    }
  };
  template <typename A, typename B, typename C, typename D>
  struct for_aux<A, B, C, D>: private static_ {
    static
    void call(A&& a, B&& b, C&& c, D d) {
      d(std::forward(a), std::forward(b), std::forward(c));
    }
  };
  // template <typename Head, typename... Tail>
  // struct for_aux: private static_ {
  //   static
  //   void call(Tail&&... x, Head f) {
  //     f(std::forward(x)...);
  //   }
  // };
  template <typename... Args>
  struct last;
  template <typename X>
  struct last<X>: private static_ {
    typedef X type;
  };
  template <typename Head, typename... Tail>
  struct last<Head, Tail...>: private static_ {
    typedef typename last<Tail...>::type type;
  };
  template <unsigned I,
            unsigned N,
            typename UnaryFunction,
            typename... Tuples>
  struct map;
  template <unsigned N, typename UnaryFunction, typename... Tuples>
  struct map<N, N, UnaryFunction, Tuples...>: private static_ {
    static
    void call(UnaryFunction, const Tuples&...) {}
  };
  template <unsigned I,
            unsigned N,
            typename UnaryFunction,
            typename... Tuples>
  struct map: private static_ {
    static
    void call(UnaryFunction f, Tuples&&... x) {
      f(std::get<I>(std::forward<Tuples>(x))...);
      map<I + 1,
        N,
        UnaryFunction,
        Tuples...>::call(f, std::forward<Tuples>(x)...);
    }
  };
  template <typename Tuple>
  struct tuple_size: private static_ {
    enum {
      value = std::tuple_size<
        typename std::remove_const<
          typename std::remove_reference<Tuple>::type
        >::type
      >::value
    };
  };
}
template <typename UnaryFunction, typename... Tuples>
inline
void map(UnaryFunction f, Tuples&&... x) {
  detail::map<0,
    detail::max<
      detail::tuple_size<Tuples>::value...
    >::value,
    UnaryFunction,
    Tuples...
  >::call(f, std::forward<Tuples>(x)...);
}
using namespace std;
struct f {
  template <typename T, typename U>
  void operator()(const T& i, const U& j) {
    cout << i << " " << j << endl;
  }
};
int main() {
  const array<int, 2> x = {{2}};
  const tuple<double, char> y(1.1, 'a');
  map(f(), x, y);
}