Почему компилятор разрешает доступ к массиву за пределами границ даже с индексом constexpr?

Чтобы гарантировать, что constexpr функции оцениваются во время компиляции, вы должны заставить их быть, сделав их результат constexpr. Например:

#include <array>

int
main()
{
    constexpr std::array<int, 5> arr{1, 2, 3, 4, 5};
    int i = arr[6];  // run time error
}

Однако:

#include <array>

int
main()
{
    constexpr std::array<int, 5> arr{1, 2, 3, 4, 5};
    constexpr int i = arr[6];  // compile time error
}

К сожалению, чтобы это действительно работало, std::array должно соответствовать спецификации C++14, а не спецификации C++11. Поскольку спецификация C++11 не помечает const перегрузку std::array::operator[] с помощью constexpr.

Так что в С++ 11 вам не повезло. В C++14 вы можете заставить его работать, но только если и array, и результат вызова оператора индекса объявлены как constexpr.

Пояснение

Спецификация С++ 11 для индексации массива гласит:

                reference operator[](size_type n);
          const_reference operator[](size_type n) const;

И спецификация С++ 14 для индексации массива гласит:

                reference operator[](size_type n);
constexpr const_reference operator[](size_type n) const;

т.е. constexpr был добавлен к перегрузке const для C++14.

Обновить

И спецификация С++ 17 для индексации массива гласит:

constexpr       reference operator[](size_type n);
constexpr const_reference operator[](size_type n) const;

Теперь цикл завершен. Вселенная может быть вычислена во время компиляции. ;-)

Если вы знаете индекс массива во время компиляции, вы можете использовать std::get с индексом, и это приведёт к ошибке компиляции, если вы выйдете за пределы

std::array<int, 4> a{{1,2,3,4}};
std::get<4>(a); // out of bounds, fails to compile

Ошибка, которую я получаю от gcc-4.9, заканчивается:

error: static assertion failed: index is out of bounds
       static_assert(_Int < _Nm, "index is out of bounds");

std::get работает только с индексами константных выражений (индекс является аргументом шаблона), поэтому с std::array он всегда может обнаружить выход за пределы во время компиляции.

Доступ к массиву std::array такой же, как и для обычного C-массива, он никогда не проверяет правильность индекса, он просто вызывает UB, если он выходит за пределы допустимого диапазона. Если вам нужны ограничения, используйте std::array::at(), который создает исключение std::out_of_range() для значений, превышать границы массива.

arr.at(EvaluateSpecialArrayIndex(4)); // terminate called after throwing
                                      // an instance of 'std::out_of_range'

Если вам нужна ошибка времени компиляции, используйте std::get:

std::get<EvaluateSpecialArrayIndex(4)>(arr); // error: static_assert failed
                                             // "index is out of bounds"

Простой ответ, потому что для std::array было бы очень дорого иметь отдельные перегрузки constexpr для проверки подобных вещей. Если вы хотите, вы можете написать свою собственную оболочку вокруг std::array, которая предлагает доступ с проверкой компиляции для констант времени компиляции. Что-то вроде:

template<typename T, size_t S>
class safeArray
{
    std::array<T, S> m_arr;
    public:
    template<size_t A>
    T& safeAt() { 
        static_assert(A < S, "Index out of bounds");
        return m_arr[A]; 
    }
    // other funcs as needed
};

Затем вы можете сделать что-то вроде:

safeArray<int, 5> arr;
cout << arr.safeAt<98>() << endl; // compile error

Однако это может генерировать множество функций. В большинстве случаев, если ваш дизайн надежен, вам никогда не понадобится этот тип проверки.