将ts ...解压缩到t0.a(),t0.b(),t1.a(),t1.b(),

Question

我想以下列方式从另一个可变参数函数调用一个可变参数函数:

template <typename ...Ts>
void f(Ts const & ...) { /* ... */ }

template <typename ...Args>
void g(Args const & ...args)
{
  // shall call f(arg0.a(), arg0.b(), arg1.a(), arg1.b(), ...)
}

我是通过以下方式完成的:

struct sentinel_t { };

template <typename Arg, typename ...Args>
void g_impl(Arg const & arg, Args const & ...args)
{
  g_impl(args..., arg.a(), arg.b());
}

template <typename ...Ts>
void g_impl(sentinel_t , Ts const & ...ts)
{
  f(ts...);
}

template <typename ...Args>
void g(Args const & ...args)
{
  g_impl(args..., sentinel_t{});
}

是否有另一种/更好的方法来实现这种模式？

Answer 1

template <class... Args> void g(Args const &... args) {
  impl::apply([](auto const &... p) { f(p...); },
              std::tuple_cat(std::forward_as_tuple(args.a(), args.b())...));
}

直到std::apply将标准化,您可以使用c ++ 14(摘自参考文献)使自己非常简单:

namespace impl {
template <typename F, typename Tuple, size_t... I>
decltype(auto) apply_impl(F &&f, Tuple &&t, std::index_sequence<I...>) {
  return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
}
template <typename F, typename Tuple> decltype(auto) apply(F &&f, Tuple &&t) {
  using Indices =
      std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>;
  return apply_impl(std::forward<F>(f), std::forward<Tuple>(t), Indices{});
}
}