std::元组获得除了最后一个元素之外的所有内容

Question

我试图返回所有元素，除了std:：tuple中的最后一个元素，如果tuple中只有两个元素，则返回第一个。由于std:：tuple有很多编译时工具，所以应该可以使用双返回类型。以下是我目前掌握的情况：

// Behavior
// init(std::make_tuple(1,2)) = 1
// init(std::make_tuple(1,2,3)) = (1,2)

// First case
template<class T1, class T2>
inline static T1 init(Tuple<T1, T2> t) {
    return std::get<0>(t);
}

// Second case
template<class ...Args, class S = std::make_index_sequence<sizeof...(Args) - 1>>
inline static decltype(auto) init(Tuple<Args...> t) {
    return std::apply([](const auto &item...) {
        return std::tuple_cat(std::make_tuple(std::get<S>) ... std::tuple<>);
    }, t);
}

如果我能以c 17友好的方式来做这件事，那就太好了。我在上述实现中遇到以下错误：

/元组。cpp:36:55:错误：包扩展不包含任何未扩展的参数包
返回std:：tuple_cat（std:：make_tuple（std:：get）。。。std:：tuple

~~~~~~~~~~~~~~~~~~~~~~~~~~~^
1生成错误。

Answer 1

其想法是实现一个helper函数，该函数将包含要复制的源元组项的索引列表：

#include <tuple>
#include <utility>
#include <cstddef>

template<typename x_Tuple, ::std::size_t... x_index> auto
make_tuple_helper(x_Tuple const & other, ::std::index_sequence<x_index...>)
{
    return ::std::make_tuple(::std::get<x_index>(other)...);
}

template<typename... x_Field> inline auto
cut_last_item(::std::tuple<x_Field...> const & other)
{
    return make_tuple_helper(other, ::std::make_index_sequence<sizeof...(x_Field) - ::std::size_t{1}>{});
}

template<> inline auto
cut_last_item(::std::tuple<> const & other)
{
    return other;
}

int main()
{
    ::std::tuple<int, short, float, double> t4{};
    ::std::tuple<int, short, float> t3{cut_last_item(t4)};
    ::std::tuple<int, short> t2{cut_last_item(t3)};
    ::std::tuple<int> t1{cut_last_item(t2)};
    ::std::tuple<> t0{cut_last_item(t1)};
    ::std::tuple<> t00{cut_last_item(t0)};
}

在线编译器

Answer 2

与您的问题无关，但模板意味着内联，您不需要静态。实际上，我认为使用static会违反ODR。你为什么用它们？您还可以使函数constexpr。进一步的改进是使用（转发）引用和std:：forward_as_tuple。以下是一个基本实现：

template <class... Args, std::size_t... Is>
constexpr auto init_helper(std::tuple<Args...> tp, std::index_sequence<Is...>)
{
    return std::tuple{std::get<Is>(tp)...};
}

template <class... Args>
constexpr auto init(std::tuple<Args...> tp)
{
    return init_helper(tp, std::make_index_sequence<sizeof...(Args) - 1>{});
}

auto test()
{
    static_assert(init(std::tuple{1})       == std::tuple{});
    static_assert(init(std::tuple{1, 2})    == std::tuple{1});
    static_assert(init(std::tuple{1, 2, 3}) == std::tuple{1, 2});
}

你在评论中说，你想看看是否有可能init（std:：tuple{1,2}）直接返回值，而不是一个值的元组。请注意，我不建议这样做，因为这会使函数的行为不一致。是的，这是可能的。而C17则使这一点非常干净：

template <class... Args>
constexpr auto init(std::tuple<Args...> tp)
{
    if constexpr (sizeof...(Args) == 2)
        return std::get<0>(tp);
    else
        return init_helper(tp, std::make_index_sequence<sizeof...(Args) - 1>{});
}

auto test()
{
    static_assert(init(std::tuple{1})       == std::tuple{});
    static_assert(init(std::tuple{1, 2})    == 1);
    static_assert(init(std::tuple{1, 2, 3}) == std::tuple{1, 2});
}