How to remove the nth element from a tuple?

Question

I'm trying to write a function that creates a new std::tuple from an existing one, with skipping the element on a given index. In example:

I have a tuple t defined as below:

constexpr auto t = std::tuple(1, 2, 3, 4);

And I want to copy it to another tuple. However, I want to skip the nth element. Let's say that in this case, the nth element I want to skip is 3 (this would mean that I want to skip the element with the index 2). This would result in a new tuple defined as:

std::tuple(1, 2, 4);

This is the closest I got until now:

template<std::size_t N, typename T, std::size_t ... is>
constexpr auto fun(T&& tp, std::index_sequence<is...>&& i) noexcept {
    return std::tuple((is != N ? std::get<is>(tp) : 0) ...);
}

template<std::size_t N, std::size_t... elems>
constexpr auto fun2() noexcept {
    constexpr auto t = std::tuple(elems...);
    return fun<N>(std::forward_as_tuple(elems...), std::make_index_sequence<sizeof...(elems)>());
}

However, instead of removing the nth element, I set it to 0.

Ideally, I would change the return argument in the function fun() to create a new tuple using multiple temporary tuples:

return std::tuple_cat((is != N ? std::tuple(std::get<is>(tp)) : std::tuple()) ...);

However, the issue with this is that the ternary operator has to have matching types on both sides.

Another approach I tried was based on recursion:

template<std::size_t N, std::size_t head, std::size_t... tail>
constexpr auto fun3() noexcept {
    if constexpr(!sizeof...(tail))
        return std::tuple(head);

    if constexpr(sizeof...(tail) - 1 == N)
        return std::tuple_cat(fun3<N, tail...>());

    if constexpr(sizeof...(tail) - 1 != N)
        return std::tuple_cat(std::tuple(head), fun3<N, tail...>());
}

However, that was even more unsuccessful. In this case, if N is equal to 0, the nth element (which is the first element here as well) will still be used in the new tuple. Also, this won't even compile, because there's an issue with the second statement:

if constexpr(sizeof...(tail) - 1 == N)

What am I missing here? How can I copy a tuple and skip one of its elements during the copy?

I'm using C++17, and I need the function to be evaluated during compile-time.

Answer 1

What about

return std::tuple_cat( foo<is, N>::func(std::get<is>(tp)) ...);

where foo is a struct with specialization as follows?

template <std::size_t, std::size_t>
struct foo
 {
   template <typename T>
   static auto func (T const & t)
    { return std::make_tuple(t); } 
 }

template <std::size_t N>
struct foo<N, N>
 {
   template <typename T>
   static std::tuple<> func (T const &)
    { return {}; } 
 }

(caution: code not tested).

This is almost your ternary operator idea but without the problem of matching the types in both sides: only the right type is instantiated.