How to can a std::array class member be statically asserted to be sorted in c++11?

How can it be asserted, during compile time, that a std::array<uint8_t, 3> class member is sorted? This would allow it to be made const, use a static_assert() and not have to call std::sort() in the constructor.

In c++20 std::is_sorted() has become a constexpr, but is not available for prior versions.

Here’s a proof of concept implementation that can be called directly on a std::array; making this more general (for other constexpr container types) is left as an exercise to the reader:

template <typename T, std::size_t N>
constexpr bool is_sorted(std::array<T, N> const& arr, std::size_t from) {
    return N - from == 0 or (arr[from - 1] <= arr[from] and is_sorted(arr, from + 1));
}

template <typename T, std::size_t N>
constexpr bool is_sorted(std::array<T, N> const& arr) {
    return N == 0 or is_sorted(arr, 1);
}

Disclaimer: This requires C++14, since, as I have mentioned in the comments, you probably cannot implement a constexpr version of is_sorted for std::array prior to C++14 due to some operations on std::array not being constexpr¹ in C++11 (operator[] / std::get<>).

With a C++14 implementation, you can use a standard for-loop in your constexpr function and use this very simple implementation:

template<typename T, std::size_t N>
constexpr bool is_sorted(std::array<T, N> const &arr) {
    for (std::size_t i = 0; i < arr.size() - 1; ++i) {
        if (arr[i] > arr[i + 1]) {
            return false;
        }
    }
    return true;
}

Note that implementing is_sorted for other containers based on iterators (array, span, string_view) probably requires C++20 since there are no such things as ConstexprIterator prior to C++20.

_{¹ It looks like gcc and clang provide these members as constexpr even with -std=c++11, so if this is okay for you, you can use one of the two other answers.}

Not as nice as the other solution, but I wanted to show that this is possible (even if annoyingly so) in C++11 (building on @KonradRudolph's solution)

Edit: This is also just C++14, since std::get is only constexpr since then. The page on it on cppref has been confusing but has since then be fixed.

#include <array>
#include <type_traits>

template<typename T, std::size_t N, std::size_t from>
constexpr typename std::enable_if<from == N, bool>::type
    is_sorted_impl(std::array<T, N> const &arr)
{
    return true;
}

template<typename T, std::size_t N, std::size_t from,
         class = typename std::enable_if<from<N>::type> 
constexpr bool is_sorted_impl(std::array<T, N> const &arr)
{
    return N - from == 0 or (std::get<from - 1>(arr) <= std::get<from>(arr) and
                             is_sorted_impl<T, N, from + 1>(arr));
}

template<typename T, std::size_t N>
constexpr bool is_sorted(std::array<T, N> const &arr)
{
    return N == 0 or is_sorted_impl<T, N, 1>(arr);
}

int main()
{
    constexpr std::array<int, 5> arr{1, 2, 3, 4, 5};
    static_assert(is_sorted(arr), "test");
}

We use std::get which was constexpr since it was introduced in C++14. To get around instantiating the std::get<N> (which gives obviously a compile time error) we specialize the function template for the case that from == N (which we need to do with enable_if since partial function template specializations are not allowed). Not nice, but possible.

On another note: @KonradRudolph's solution compiles under gcc and clang also with -std=c++11 -pedantic, altough it should not due to the operator[] not being constexpr is this a bug?