将fold表达式与std::一起用于两个元组

Using fold expression with std::apply on two tuples

本文关键字：元组 两个 一起 表达式 fold std 用于      更新时间：2023-10-16

我刚开始学习C++17倍表达式。我知道可以将fold表达式应用于元组，就像下面的例子一样(灵感来自对这个问题的回答(：

#include <iostream>
#include <tuple>
int main() {
std::tuple in{1, 2, 3, 4};
std::cout << "in = ";
std::apply([](auto&&... x) { ((std::cout << x << ' '), ...); }, in);
std::cout << std::endl;
std::multiplies<int> op;
auto out = std::apply([&](auto&& ...x) { return std::tuple{op(x, 3)...}; }, in);
std::cout << "out = ";
std::apply([](auto&&... x) { ((std::cout << x << ' '), ...); }, out);
std::cout << std::endl;
}

输出：

in = 1 2 3 4
out = 3 6 9 12

是否可以使用类似的方法将两个元组压缩在一起？参考上面的例子，我想用另一个元组来替换常数3，比如这个假设版本的std:：apply:

auto out = std::apply([&](auto&& ...x, auto&& ...y) { return std::tuple{op(x, y)...}; }, inX, inY);

如果折叠表达式不适用于此目的，是否有其他方法可以在C++20中实现相同的结果(除了模板递归和/oriSFINAE(？

您可以apply两次：

auto out = std::apply([&](auto&&... x){
return std::apply([&](auto&&... y){
return std::make_tuple(op(x, y)...);
}, inY);
}, inX);

或者，您可以使用索引序列，这在C++20中更容易，因为我们有更通用的lambda语法，尽管仍然相当密集：

auto out = [&]<size_t... Is>(std::index_sequence<Is...>){
return std::make_tuple(op(std::get<Is>(inX), std::get<Is>(inY))...);
}(std::make_index_sequence<std::tuple_size_v<decltype(inX)>>());

可能值得添加一个像。。。

auto indices_for = []<typename... Ts>(std::tuple<Ts...> const&){
return = []<size_t... Is>(std::index_sequence<Is...>){
return [](auto f) -> decltype(auto) {
return f(std::integral_constant<size_t, Is>()...);
};
}(std::index_sequence_for<Ts...>());
};

也就是说，indices_for(t)为您提供了一个函数，该函数接受一个函数并用一组积分常数调用它。这是一个混乱，但它是一个烂摊子，你必须写一次，可以很容易地测试。这可以让你写：

auto out = indices_for(inX)([&](auto... Is){
return std::make_tuple(op(std::get<Is>(inX), std::get<Is>(inY))...);
});

类似的东西。

相关文章：