Transforming an array of int to integer_sequence

Question

I would like to know if there is a way to transform a std::array into an index sequence?

constexpr std::array<int, 5> x = {0, 3, 4, 5, 8};

constexpr auto integer_sequence = ...; // something that lead to integer_sequence<int, 0, 3, 4, 5, 8>;

I know that it is impossible to use a function, because it will lead to another type. However, since it is possible to do something like :

constexpr std::size_t x = 8;
std::integral_constant<int, x> height;

Is it possible to do it in a simple way?

I tried to do the following :

#include <array>
#include <tuple>

template<std::size_t N>
constexpr std::array<int, N> m_iota(int value) {
    std::array<int, N> result{};
    for(auto &v : result)
        v = value++;
    return result;
}

template<int N>
using Int = std::integral_constant<int, N>;

int main() {
    constexpr auto array = m_iota<5>(3); // 3, 4, 5, 6, 7
    constexpr auto indexer = std::tuple<Int<0>,Int<1>,Int<2>,Int<3>,Int<4>>{};

    auto to_sequence = [array](auto ...is) {return std::integer_sequence<int, array[is]...>{};};
    auto x = std::apply(to_sequence, indexer);
    static_assert(std::is_same_v<decltype(x), std::integer_sequence<int, 3, 4, 5, 6, 7>>);
}

It compiles well on GCC and clang, but not in MSVC... Is there simpler way?

Here a link to msvc : https://godbolt.org/z/EK7azW

Interesting, I just get one error, latest VC,c++17. invalid template argument for 'std::integer_sequence', expected compile-time constant expression in the to_sequence lambda. And that makes sense to me. — lakeweb
– lakeweb, Commented Oct 13, 2020 at 22:31
@lakeweb to me it does not because array is constexpr, and is are constexpr convertible to std::size_t. Maybe using decltype(is)::value? However gcc7.5 does not compile too... It is interesting ahaha — Antoine Morrier
– Antoine Morrier, Commented Oct 13, 2020 at 22:44
If I comment std::apply down, it does compile as constant, as it is no longer being used as a callable object. That makes sense to me. But I'm no expert where it comes to compile time programing. — lakeweb
– lakeweb, Commented Oct 13, 2020 at 23:09
Wouldn't it be easier to have it originally as an index sequence type, and then make a constexpr array out of that? — Anonymous1847
– Anonymous1847, Commented Oct 14, 2020 at 0:07
@Anonymous1847: It's not the answer to this question per the tags, but std::array<T> can be a template parameter (for suitable T) in C++20. — Davis Herring
– Davis Herring, Commented Oct 14, 2020 at 5:23

Davis Herring · Accepted Answer · 2020-10-14 05:37:27Z

6

While (in C++17) std::array<T> can't be a template parameter type, const std::array<T>& can be. Thus, with the restriction that the array in question have static storage duration, you can write

#include<array>
#include<utility>
#include<type_traits>
#include<cstddef>

template<const auto &A,
         class=std::make_index_sequence<
           std::tuple_size<std::decay_t<decltype(A)>>::value>>
struct as_sequence;
template<const auto &A,std::size_t ...II>
struct as_sequence<A,std::index_sequence<II...>> {
    using type=std::integer_sequence<
      typename std::decay_t<decltype(A)>::value_type,A[II]...>;
};

constexpr std::array<int, 5> x = {0, 3, 4, 5, 8};
static_assert(std::is_same_v<as_sequence<x>::type,
                std::integer_sequence<int, 0, 3, 4, 5, 8>>);

which works on every modern compiler.

answered Oct 14, 2020 at 5:37

Davis Herring

42k4 gold badges59 silver badges92 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Anonymous1847 Over a year ago

Const references as template parameters? That's new to me. Interesting.

Anonymous1847 · Accepted Answer · 2020-10-14 00:24:59Z

1

You can try this:

constexpr std::array<int, 5> x = {0, 3, 4, 5, 8};

template <int prepender, typename sequence>
struct prepend_integer_to_sequence {};

template <int prepender, int... sequence_nums>
struct prepend_integer_to_sequence<prepender, std::integer_sequence<int, sequence_nums...> > {
    using type = std::integer_sequence<int, prepender, sequence_nums...>;
};
    
template <int prepender, typename sequence>
using prepend_integer_to_sequence_t = typename prepend_integer_to_sequence<prepender, sequence>::type;


template <size_t begin>
struct convert_array {
    using type = prepend_integer_to_sequence_t<
        x[begin],
        typename convert_array<begin + 1>::type
    >;
};

template <>
struct convert_array<x.size()> {
    using type = std::integer_sequence<int>;
};

using int_seq = typename convert_array<0>::type;

answered Oct 14, 2020 at 0:24

Anonymous1847

2,63813 silver badges19 bronze badges

1 Comment

m7913d Over a year ago

It may be useful to explain your solution, instead of only providing a corrected code sample.

Collectives™ on Stack Overflow

Transforming an array of int to integer_sequence

2 Answers 2

1 Comment

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related