C++ constexpr : Compute a std array at compile time

Question

I want to convert an "array" of bool to a integer sequence. So I need to compute an std::array at compile time.

Here is my code

#include <array>

template<typename InputIt, typename T >
inline constexpr typename std::iterator_traits<InputIt>::difference_type
count( InputIt first, InputIt last, const T &value ) {
    typename std::iterator_traits<InputIt>::difference_type ret = 0;
        for (; first != last; ++first) {
            if (*first == value) {
                ret++;
            }
        }
        return ret;
}

template<bool ..._values>
struct keep_value {
    static constexpr std::size_t numberOfValues = sizeof...(_values);
    static constexpr bool values[] = {_values...};
    static constexpr std::size_t numberToKeep = count(values, values + numberOfValues, true);

    static constexpr std::array<std::size_t, numberToKeep> computeIndices() {
        std::array<std::size_t, numberToKeep> array{};
        auto it = array.begin();
        for(std::size_t i{0}; i < numberOfValues; ++i)
            if(values[i] == true)
                *it++ = i;

        return array;
    }

    static constexpr std::array<std::size_t, numberToKeep> indices = computeIndices();

    template<typename Indices = std::make_index_sequence<numberToKeep>>
    struct as_index_sequence{};

    template<std::size_t ...Is>
    struct as_index_sequence<std::index_sequence<Is...>> : std::index_sequence<indices[Is]...>{};
};

int main() {
    keep_value<false, true, true>::template as_index_sequence<>{}; // Should return the sequence 1 2
}

I get an error for the line that call the computeIndices function. Is this code c++14 correct? Is it possible to do otherwise? I am using MSVC and I get this error : expression did not evaluate to a constant

Clang seems to give the same error when using c++14, however, compiles is with c++17 — JVApen
– JVApen, Commented Mar 4, 2018 at 16:03
Hmm, maybe the functions are not constexpr in C++14, but are in C++17. The same for std::count that will be constexpr in C++20 — Antoine Morrier
– Antoine Morrier, Commented Mar 4, 2018 at 16:05

JVApen · Accepted Answer · 2018-03-04 16:05:58Z

7

This code looks correct and works when compiled as C++17. It uses std::array::begin, which only has been made constexpr in C++17.

A better compilation error can be achieved when using clang, which states:

<source>:23:25: note: non-constexpr function 'begin' cannot be used in a constant expression
    auto it = array.begin();

answered Mar 4, 2018 at 16:05

JVApen

11.5k5 gold badges37 silver badges80 bronze badges

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

Comments

max66 · Accepted Answer · 2018-03-04 17:56:17Z

2

Is it possible to do otherwise?

About correctness answered JVApen (+1).

A possible alternative is avoid std::array at all and construct the index sequence in a recursive way using template specialization

The following is a full compilable example

#include <utility>
#include <type_traits>

template <typename, std::size_t, bool...>
struct bar;

// true case
template <std::size_t ... Is, std::size_t I, bool ... Bs>
struct bar<std::index_sequence<Is...>, I, true, Bs...>
   : public bar<std::index_sequence<Is..., I>, I+1U, Bs...>
 { };

// false case
template <std::size_t ... Is, std::size_t I, bool ... Bs>
struct bar<std::index_sequence<Is...>, I, false, Bs...>
   : public bar<std::index_sequence<Is...>, I+1U, Bs...>
 { };

// end case
template <typename T, std::size_t I>
struct bar<T, I>
 { using type = T; };

template <bool ... Bs>
struct foo : public bar<std::index_sequence<>, 0U, Bs...>
 { };

int main()
 {
   static_assert( std::is_same<typename foo<false, true, true>::type,
                               std::index_sequence<1U, 2U>>{}, "!" );
 }

If you don't like the recursive solutions, I propose (just for fun) another solution based of std::tuple_cat

#include <tuple>
#include <utility>
#include <type_traits>

template <std::size_t, bool>
struct baz
 { using type = std::tuple<>; };

template <std::size_t I>
struct baz<I, true>
 { using type = std::tuple<std::integral_constant<std::size_t, I>>; };

template <std::size_t I, bool B>
using baz_t = typename baz<I, B>::type;

template <typename, bool...>
struct bar;

template <std::size_t ... Is, bool ... Bs>
struct bar<std::index_sequence<Is...>, Bs...>
 {
   template <std::size_t ... Js>
   constexpr static std::index_sequence<Js...>
      func (std::tuple<std::integral_constant<std::size_t, Js>...> const &);

   using type = decltype(func(std::tuple_cat(baz_t<Is, Bs>{}...)));
 };


template <bool ... Bs>
struct foo : public bar<std::make_index_sequence<sizeof...(Bs)>, Bs...>
 { };

int main()
 {
   static_assert( std::is_same<typename foo<false, true, true>::type,
                               std::index_sequence<1U, 2U>>{}, "!" );
 }

edited Mar 4, 2018 at 17:56

answered Mar 4, 2018 at 16:23

max66

67k11 gold badges76 silver badges121 bronze badges

2 Comments

Antoine Morrier Over a year ago

+1 : I prefer your first version ^^. However I made my own constepr_array and it solves the problem :). Thanks

max66 Over a year ago

@AntoineMorrier - The second one is mainly for fun. Anyway I think is a interesting technique because, using std::tuple_cat permit to insert, on not insert, something at compile time and avoiding a recursive solution.

Collectives™ on Stack Overflow

C++ constexpr : Compute a std array at compile time

2 Answers 2

Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related