是否有一个元组 for_each() 返回从调用的函数返回的所有值的元组？

Question

几个月前我浏览了this tuple for_each() implementation，想知道是否有可能实现一个版本，将调用函数的返回值收集到一个元组中？

我想在我的代码库中执行此操作的原因是，我有以下函数，它接受一个形状的可变参数列表的输入，并返回一个值的元组。

template <typename... T, typename... R>
static constexpr auto map_to_opengl(T &&... shapes)
{
  return std::make_tuple(shape_mapper::map_to_array_floats(shapes)...);
}

好吧，我想更改我的函数签名以接受形状元组，并返回在每个形状上调用函数的结果（这在语义上应该与上面的代码等效）。如果我能做到这一点，我可以让我的代码更加干燥，这对我来说很重要。

template <typename... T, typename... R>
static constexpr auto map_to_opengl(std::tuple<T...> &&shapes)
{
  return tuple_foreach(shapes, &shape_mapper::map_to_array_floats);
}

但是tuple_foreach 的实现不允许收集任何值。能不能写出这样的函数？如果它存在于 Hana，我错过了它:(

我猜你不会称这个算法为 for_each，但可能会累积？我不确定这里。

Answer 1

使用std::apply 将遵循以下原则：

template<typename T, typename F>
constexpr auto map_tuple_elements(T&& tup, F f) {
    return std::apply([&f](auto&&... args){
               return std::make_tuple(f(decltype(args)(args))...);    
           }, std::forward<T>(tup));
}

Answer 2

在 C++17 的标准库中没有添加任何对这里特别有帮助的东西（我能想到的）；这是作为独立算法的常用 C++14 方法（使用包扩展）：

namespace detail {
    template<typename T, typename F, std::size_t... Is>
    constexpr auto map_tuple_elements(T&& tup, F& f, std::index_sequence<Is...>) {
        return std::make_tuple(f(std::get<Is>(std::forward<T>(tup)))...);
    }
}

template<typename T, typename F, std::size_t TupSize = std::tuple_size_v<std::decay_t<T>>>
constexpr auto map_tuple_elements(T&& tup, F f) {
    return detail::map_tuple_elements(
        std::forward<T>(tup), f,
        std::make_index_sequence<TupSize>{}
    );
}

Online Demo

Answer 3

下面的main() 构造一个元组，对元组中的每个值应用一个函数，并产生另一个元组。你可以简单地将整个东西包装成一个自己的函数。

此解决方案使用了一些 C++17 的新模板，但如有必要，它们都可以轻松地为 C++14 重新实现：

#include <utility>
#include <tuple>
#include <iostream>

// The function

int square(int n)
{
    return n * 2;
}

// The helper class for unpacking a tuple into a parameter pack,
// invoking square(), then packing the result back into a tuple.

template<typename tuple, typename index_sequence> class apply_square;

template<typename tuple,
     size_t... sequence>
class apply_square<tuple, std::index_sequence<sequence...>> {

public:

    template<typename tuple_arg>
    static auto do_apply_square(tuple_arg &&tupple)
    {
        return std::make_tuple(square(std::get<sequence>(tupple))...);
    }
};

int main()
{
    // Create a sample tuple

    auto f=std::make_tuple(1, 2);

    // Invoke appropriately-specialized do_apply_square() against
    // the tuple.

    typedef std::make_index_sequence<std::tuple_size<decltype(f)>
                     ::value> tuple_indexes;

    auto f_squared=apply_square<decltype(f), tuple_indexes>
        ::do_apply_square(f);

    // f_squared should now be another tuple. Let's see:

    int &first=std::get<0>(f_squared);
    int &second=std::get<1>(f_squared);

    std::cout << first << ' ' << second << std::endl;
}