c++ - 将多个元组应用于同一个函数(即 `apply(f, tuples...)` )而不递归或 `tuple_cat`

Question

std::experimental::apply具有以下签名:

template <class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t);

它基本上通过扩展 t 的元素作为参数来调用 f。

---

我想要做完全相同的事情，但同时有多个元组:

template <class F, class... Tuples>
constexpr decltype(auto) multi_apply(F&& f, Tuples&&... ts);

示例用法:

std::tuple t0{1, 2, 3};
std::tuple t1{4, 5, 6};
auto sum = [](auto... xs){ return (0 + ... + xs); };

assert(multi_apply(sum, t0, t1) == 1 + 2 + 3 + 4 + 5 + 6);

---

我可以想到各种实现 multi_apply 的简单方法:

• 使用 std::tuple_cat然后调用 std::experimental::apply。

• 使用递归将每个元组的参数绑定(bind)到最终调用原始函数的一系列 lambda。

但我要问的是:如何在不求助于 std::tuple_cat 或递归的情况下实现 multi_apply？

理想情况下，我想做的是:生成一个 std::index_sequence对于每个元组，并将每个元组与其自己的索引序列匹配在相同的可变参数扩展中。这可能吗？示例:

// pseudocode-ish
template <class F, std::size_t... Idxs, class... Tuples>
constexpr decltype(auto) multi_apply_helper(
    F&& f, std::index_sequence<Idxs>... seqs,  Tuples&&... ts)
{
    return f(std::get<Idxs>(ts)...);
} 

Answer 1

这是我的看法。它不使用递归并在同一个包扩展中扩展这些元组，但它需要一些准备工作:

• 我们构建了一个元组，其中包含对传入的元组的引用、右值参数的右值引用、左值参数的左值引用，以便在最终调用中进行适当的转发(正是 std::forward_as_tuple 所做的，正如 T.C. 在注释)。元组被构建并作为右值传递，因此引用折叠确保在对 f 的最终调用中每个参数的正确值类别.
• 我们构建了两个扁平索引序列，它们的大小都等于所有元组大小的总和:
  • 外部索引选择元组，因此它们重复相同的值(元组包中元组的索引)的次数等于每个元组的大小。
  • 内部的选择每个元组中的元素，因此它们从 0 增加比每个元组的元组大小小一。

一旦我们准备就绪，我们只需在对 f 的调用中扩展两个索引序列。 .

#include <tuple>
#include <array>
#include <cstddef>
#include <utility>
#include <type_traits>
#include <iostream>

template<std::size_t S, class... Ts> constexpr auto make_indices()
{
   constexpr std::size_t sizes[] = {std::tuple_size_v<std::remove_reference_t<Ts>>...};
   using arr_t = std::array<std::size_t, S>;
   std::pair<arr_t, arr_t> ret{};
   for(std::size_t c = 0, i = 0; i < sizeof...(Ts); ++i)
      for(std::size_t j = 0; j < sizes[i]; ++j, ++c)
      {
         ret.first[c] = i;
         ret.second[c] = j;
      }
   return ret;
}

template<class F, class... Tuples, std::size_t... OuterIs, std::size_t... InnerIs> 
constexpr decltype(auto) multi_apply_imp_2(std::index_sequence<OuterIs...>, std::index_sequence<InnerIs...>, 
                                           F&& f, std::tuple<Tuples...>&& t)
{
   return std::forward<F>(f)(std::get<InnerIs>(std::get<OuterIs>(std::move(t)))...);
}

template<class F, class... Tuples, std::size_t... Is> 
constexpr decltype(auto) multi_apply_imp_1(std::index_sequence<Is...>, 
                                           F&& f, std::tuple<Tuples...>&& t)
{
   constexpr auto indices = make_indices<sizeof...(Is), Tuples...>();
   return multi_apply_imp_2(std::index_sequence<indices.first[Is]...>{}, std::index_sequence<indices.second[Is]...>{},
      std::forward<F>(f), std::move(t));
}

template<class F, class... Tuples> 
constexpr decltype(auto) multi_apply(F&& f, Tuples&&... ts)
{
   constexpr std::size_t flat_s = (0U + ... + std::tuple_size_v<std::remove_reference_t<Tuples>>);
   if constexpr(flat_s != 0)
      return multi_apply_imp_1(std::make_index_sequence<flat_s>{}, 
         std::forward<F>(f), std::forward_as_tuple(std::forward<Tuples>(ts)...));
   else
      return std::forward<F>(f)();
}

int main()
{
   auto t0 = std::make_tuple(1, 2);
   auto t1 = std::make_tuple(3, 6, 4, 5);
   auto sum = [](auto... xs) { return (0 + ... + xs); };

   std::cout << multi_apply(sum, t0, t1, std::make_tuple(7)) << '\n';
}

它以 C++1z 模式在 Clang 和 GCC 的主干版本上编译。在生成的代码方面，GCC 与 -O2优化对 multi_apply 的调用到常数 28 .

---

替换 std::array内部有一个内置数组 make_indices通过 using arr_t = std::size_t[S];使其在 Clang 3.9.1 上编译(该版本的 libc++ 在 constexpr 的 std::array 上缺少 operator[])。

进一步替换std::tuple_size_v与 std::tuple_size<X>::value并删除 if constexpr在 multi_apply 中测试使其在 GCC 6.3.0 上编译。 (测试处理没有传入元组或传入的所有元组为空的情况。)

进一步用类似的调用替换折叠表达式的使用

sum_array({std::tuple_size_v<std::remove_reference_t<Tuples>>...})

哪里sum_array可以是一些简单的东西，比如

template<class T, std::size_t S> constexpr T sum_array(const T (& a)[S], std::size_t i = 0)
{
   return i < S ? a[i] + sum_array(a, i + 1) : 0;
}

使其在最新的 MSVC 2017 RC 上编译(MSVC 实际上有 std::tuple_size_v ，但它需要其他更改)。生成的代码仍然很棒:替换了 sum 的主体之后lambda sum_array({xs...}) ，生成的代码是对 sum_array 的直接调用使用直接从所有元组的元素就地构建的数组，所以 multi_apply机器不会引入任何运行时开销。

---

std::apply是根据 INVOKE 定义的，因此，为了保持一致，最后调用 f应该是

std::invoke(std::forward<F>(f), std::get<InnerIs>(std::get<OuterIs>(std::move(t)))...)

实现可能会在 std::apply 上提供一个 noexcept 说明符(至少，libc++ 有；libstdc++ 和 MSVC 目前没有)所以这也值得考虑。