为什么`std :: array :: at（）`没有实现为模板函数？

Question

Edit: I forgot to mention that this would be in a constexpr context where there aren't any dynamical indices.

Consider the following (very naive) implementation:

template <class T, std::size_t N>
class array
{
    // ...

    template <size_type pos>
    reference at()
    {
        static_assert(pos < N, "Index out of range.");
        return m_data[pos];
    }
}

With the following usage:

int main()
{
    array<int, 5> a{1, 2, 3, 4, 5};

    cout << a.at(10) << "\n";   // will throw at runtime

    cout << a.at<10>() << "\n"; // static assert error; index out of range
    return 0;
}

This effectively prevents out of range access for the types and any nasty segfaults or exceptions that would be thrown. An error would be thrown by the compiler that looks like this:

error: static assertion failed: Index out of range
             static_assert(pos < N, "Index out of range");

And most IDEs would catch the erroneous access. So why is it not implemented as such?

Note: I'm sorry if this is obvious but I'm planning on writing my own array class for performance and safety, and this thought popped into my head.

Answer 1

You need to be able to access the elements dynamically. Only because the size is known at compile-time does not mean that the accessed indices are known at compile-time. Consider a.at(i) where i is user input.

Furthermore, the at function is required to do a runtime-check by the standard, see [sequence.reqmts]

The member function at() provides bounds-checked access to container elements. at() throws out_of_range if n >= a.size() .

Also, starting with C++17 the at member function is marked constexpr, so for an index which is constant at compile-time there is no difference to the templated function in your question.

#include <array>

int main() {
    constexpr std::array<int,5> a = { 1, 2, 3, 4, 5 };
    constexpr int b = a.at(2);
    constexpr int c = a.at(10);
}

Live on Wandbox (Error message is meh...)

If you known the index at compile-time and do not want to pay the extra cost that at incurs before C++17, you can just use std::get<10>(a) . This variant has zero-overhead, because the compiler can inline the array access entirely

#include <array>

int test(std::array<int,5> const &a) {
  return std::get<1>(a);
}

Live on Godbolt

Answer 2

You can use std::get for that purpose:

#include <array>
#include <iostream>

int main() {
    constexpr std::array<int, 4> foo { 1, 2, 3, 4 };
    std::cout << std::get<2>(foo) << std::endl;
}

Also note that both operator[] and at are constexpr :

constexpr std::array<int, 4> foo { 1, 2, 3, 4 };
std::cout << std::get<foo[2]>(foo) << std::endl;
std::cout << std::get<foo.at(2)>(foo) << std::endl;

This evaluates to std::get<3>(foo) (which evaluates to 4, since it's also a constexpr ).

Compilation already fails if you try to use an index out of the array's bounds in a constexpr .

Finally, as multiple people have already pointed out, one major benefit of arrays is that you can read at dynamic indices from them. IMO, you are overstating the usefulness of static indexing.

Answer 3

So why is it not implemented as such?

Because in your way can works only with values known at compile time.

I mean... with at() defined as receiving a parameter (not template), you can write

for ( auto i = 0U ; i < 4U ; ++i )
   std::cout << a.at(i) << std::endl;

But you can't write

for ( auto i = 0U ; i < 4U ; ++i )
   std::cout << a.at<i>() << std::endl;

because i isn't known (fixed) ar compile time.

-- EDIT--

The OP write

What I really wanted is to enforce the bound checking at compile time

If you write at() as follows

constexpr T & at (std::size_t pos)
 { return pos < N ? m_data[pos] : throw std::range_error("out of range"); }

you get a bound checking compile time, when the method is constexpr executed compile time, and run time otherwise.

Answer 4

Obviously we wouldn't want to have only indices that are compile-time constants. If you're asking “why not also have a function template for safe access with constant-expression indices?”, I can say only that the use case seems not very common (unlike for std::tuple ) and that the client can implement it themselves with no difficulty or loss of performance (which is one of the usual criteria for inclusion in the standard library).

Re comments: even in a constexpr function, you can't use a normal function parameter as a template argument.

Answer 5

Beyond what has been pointed out about at having to take a runtime argument, and std::get as an alternative: if you use operator[] in a constexpr context and go out of bounds you will get a compile time error in C++14 as you seem to want, as long as you invoke it on a const array:

const std::array<int, 5> a{};
constexpr int v = a[10];

gcc gives the error:

error: array subscript value ‘10’ is outside the bounds of array type ‘std::__array_traits<int, 5>::_Type {aka int [5]}’
   constexpr int v = a[10];