Question

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

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

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

我想要的东西完全相同，但同时有多个元组：

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。
使用递归将每个元组的参数绑定到最终调用原始函数的一系列lambda中。

但我要问的是：如何在不诉诸multi_apply或递归的情况下实施std::tuple_cat？

我理想的做法是：为每个元组生成一个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

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

我们构建一个对传入的元组的引用元组，rvalue参数的rvalue引用，lvalue参数的左值引用，以便在最终调用中正确转发（正如std::forward_as_tuple所做的那样，如TC所述在评论中）。元组构建并作为右值传递，因此引用折叠可确保在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的主干版本。就生成的代码而言，使用-O2的GCC会将对multi_apply的调用优化为常量28。

用std::array内的make_indices内置数组替换using arr_t = std::size_t[S];使其在Clang 3.9.1上编译（该版本的libc ++在{{1}上缺少constexpr } {s} std::array）。

进一步用operator[]替换std::tuple_size_v并删除std::tuple_size<X>::value中的if constexpr测试，使其在GCC 6.3.0上编译。（测试处理没有传入元组或传入的所有元组都为空的情况。）

进一步用像

这样的调用替换fold表达式的用法

multi_apply

其中sum_array({std::tuple_size_v<std::remove_reference_t<Tuples>>...})可以是简单的

sum_array

使其在最新的MSVC 2017 RC上编译（MSVC实际上有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; }，但它需要其他更改）。生成的代码仍然很棒：在用std::tuple_size_v替换sum lambda的主体之后，生成的代码是对sum_array({xs...})的直接调用，其中数组直接从元素内置所有元组都是如此，因此sum_array机制不会引入任何运行时开销。

multi_apply是根据 INVOKE 定义的，因此，为了保持一致，对std::apply的最终调用应为

实现可能会在std::invoke(std::forward<F>(f), std::get<InnerIs>(std::get<OuterIs>(std::move(t)))...)上提供一个noexcept-specifier（至少，libc ++会这样做; libstdc ++和MSVC目前没有），所以这也值得考虑。

Answer 2

备用版本：

template <class F, std::size_t... Is, class ... Ts>
constexpr decltype(auto) multiple_apply_impl(F&& f, std::index_sequence<Is...>, Ts&&... ts)
{
    constexpr auto p = [](){
        constexpr auto total_size = sizeof...(Is);
        std::array<std::size_t, total_size> outer{};
        std::array<std::size_t, total_size> inner{};
        std::size_t global_index = 0;
        std::size_t outer_value = 0;

        [[maybe_unused]] auto l = [&](std::size_t size)
        {
            for (std::size_t i = 0; i != size; ++i) {
                outer[global_index] = outer_value;
                inner[global_index] = i;
                ++global_index;
            }
            ++outer_value;
        };
        (l(std::tuple_size<std::decay_t<Ts>>::value), ...);

        return make_pair(outer, inner);
    }();
    [[maybe_unused]] constexpr auto outer = p.first;
    [[maybe_unused]] constexpr auto inner = p.second;

    using std::get;
    return std::invoke(std::forward<F>(f),
                       get<inner[Is]>(get<outer[Is]>(std::forward_as_tuple(std::forward<Ts>(ts)...)))...);
}

template <class F, class ... Ts>
constexpr decltype(auto) multiple_apply(F&& f, Ts&&... ts)
{
    constexpr auto total_size = (std::size_t{0} + ... + std::tuple_size<std::decay_t<Ts>>::value);

    return multiple_apply_impl(std::forward<F>(f),
                               std::make_index_sequence<total_size>(),
                               std::forward<Ts>(ts)...);
}

Demo

将多个元组应用于同一个函数（即`apply（f，tuples ...）`）而不进行递归或`tuple_cat`

2 个答案: