为什么我初始化数组容器的元素大于数组大小时没有出错？

Question

I noticed that when I initialize array like so:

std::array<int,3> myarray;

myarray[0] = 9;
myarray[1] = 8;
myarray[2] = 7;
myarray[3] = 6;
myarray[4] = 5;

I do not get an error, even though I have more array elements than was defined in <int,3>

I am on Mac with g++ and it's C++11.

So I guess my question is: why is that, that there are no errors? Is it correct behavior? Or do I expect too much form my compiler?

Also what is this method of initialization called? Someone called it "buggy construction". I think they meant it as a joke though.

PS I understand that this method is undesirable .

EDIT: Some folks suggested that my question is a duplicate . But according to the best answer from Vlad it does not seem to be. According to Vlad my question is about operator overloading and not C style array range. I have to trust his expertise and what he said just makes sense.

Answer 1

It is undefined behavior . The compiler does not have to warn you about undefined behavior.

If you really want to know when you have gone out of the bounds of the array then use at() which will throw an exception.

Answer 2

In general the compiler does not check indices used in the subscript operator for arrays.

As for the class std::array then the subscript operator is overloaded and looks like for example

T & operator []( size_t i );

So this record

myarray[4] = 5;

is equivalent to

myarray.operator []( 4 ) = 5;

that syntactically is correct. So the compiler does not have a reason for issueing an error.

Answer 3

... why is that, that there are no errors? Is it correct behaviour?

Well, the code invokes undefined behaviour . As you have observed it, it could do nothing apparent, or it could also throw a runtime error.

In these situation there are generally three types of errors you can run into;

• Compile time array initialisation errors
• Run time out of bounds error
• Undefined behaviour

Compile time array initialisation errors

When initialising an array with more elements that the size of the array, the compiler can and does issue an error. It has sufficient information to diagnose these and as such, it does.

std::array<int,3> my_array = {1, 2, 3, 4, 5}; // compiler error

Run time out of bounds error

When indexing into the std::array (and other standard library containers), there are generally two forms; using the index operator [] or using a member method at() . The index operator is generally implemented for performance and hence won't do any bounds checking, the at() on the other hand does do bounds checking and will throw an exception if the indexed element is larger that the array size.

The compiler generally does not have sufficient information to diagnose these conditions as errors, hence it won't - but you might get a warning. Other tools make exist to catch these errors during the build (as could be possible in the sample given).

Undefined behaviour

This is basically the alternate situation to the bounds check. If you index an element out of the bounds of the error, the behaviour is undefined. It may result in a segmentation fault (or access violation), or it may not throw any runtime error or exception.

Answer 4

If you implement it using Microsoft's GSL span it will fail fast as promised by Neil Macintosh. So maybe not desirable in either case but with this approach the program terminates and indicates an issue worth investigating.

array<int, 3> a;
a[0] = 0;
a[1] = 1;
a[2] = 2;
a[3] = 3;
a[4] = 4;

for (auto& i : a) {
    cout << i << endl;
}

gsl::span<int, 3> s = a;
s[0] = 10;
s[1] = 11;
s[2] = 12;
//    s[3] = 13;

for (auto& i : s) {
    cout << i << endl;
}

outputs

0
1
2
10
11
12

Uncommenting s[3] = 13 compiles but fails.

0
1
2
libc++abi.dylib: terminating
zsh: abort      ./gsl_span