在元组上推广 for_each 以接受可变数量的参数

Question

目前，我有：

template <unsigned I,
          unsigned N,
          typename Tuple,
          typename UnaryFunction>
struct for_;

template <unsigned N, typename Tuple, typename UnaryFunction>
struct for_<N, N, Tuple, UnaryFunction> {
  static
  void call(const Tuple&, UnaryFunction) {}
};

template <unsigned I,
          unsigned N,
          typename Tuple,
          typename UnaryFunction>
struct for_ {
  static
  void call(Tuple&& x, UnaryFunction f) {
    f(get<I>(x));
    for_<I + 1, N, Tuple, UnaryFunction>::call(std::forward<Tuple>(x), f);
  }
};

template <typename Tuple, typename UnaryFunction>
inline
void for_each(Tuple&& x, UnaryFunction f) {
  for_<0,
    tuple_size<
      typename std::remove_const<
        typename std::remove_reference<Tuple>::type
      >::type
    >::value,
    Tuple,
    UnaryFunction>::call(std::forward<Tuple>(x), f);
}

是否可以通过可变参数模板来概括这一点，以采用任意数量的元组参数？

编辑：

这是我将如何使用我无法定义的内容：

if (i != e) {
  std::array<Tuple, 2> x;
  std::get<0>(x) = *i;
  std::get<1>(x) = *i;
  ++i;
  std::for_each (i, e, [&x](const Tuple& y) {
    for_each(std::get<0>(x), y, assign_if(std::less));
    for_each(std::get<1>(x), y, assign_if(std::greater));
  });
}

编辑：更改为使用右值引用和 std::forward

Answer 1

我不确定这是否是您所期望的，但我会发布它 - 也许有人会发现它有帮助。

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());

Answer 2

您可以在此处查看我的答案，以获取有关扩展元组的提示

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

Answer 3

请参阅下面的 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);
}