Why compiler does not complain about accessing elements beyond the bounds of a dynamic array? [duplicate]_问答_开发者

This question already has answers here: Accessing an array out of bounds gives no error, why? (18 answers) Closed 7 years ago.

The community reviewed whether to reopen this question 1 year ago and left it closed:

Duplicate This question has been answered, is not unique, and doesn’t differentiate itself from another question.

I am defining an array of size 9. but when I access the array index 10 it is not giving any error.

int main() {
   bool* isSeedPos = new bool[9];
   isSeedPos[10] 开发者_C百科= true;
}

I expected to get a compiler error, because there is no array element isSeedPos[10] in my array.

Why don't I get an error?

It's not a problem.

There is no bound-check in C++ arrays. You are able to access elements beyond the array's limit (but this will usually cause an error).

If you want to use an array, you have to check that you are not out of bounds yourself (you can keep the sizee in a separate variable, as you did).

Of course, a better solution would be to use the standard library containers such as std::vector. With std::vector you can either

use the myVector.at(i)method to get the ith element (which will throw an exception if you are out of bounds)
use myVector[i] with the same syntax as C-style arrays, but you have to do bound-checking yourself ( e.g. try if (i < myVector.size()) ... before accessing it)

Also note that in your case, std::vector<bool> is a specialized version implemented so that each booltakes only one bit of memory (therefore it uses less memory than an array of bool, which may or may not be what you want).

Use std::vector instead. Some implementations will do bounds checking in debug mode.

No, the compiler is not required to emit a diagnostic for this case. The compiler does not perform bounds checking for you.

It is your responsibility to make sure that you don't write broken code like this, because the compiler will not error on it.

Unlike in other languages like java and python, array access is not bound-checked in C or C++. That makes accessing arrays faster. It is your responsibility to make sure that you stay within bounds.

However, in such a simple case such as this, some compilers can detect the error at compile time.

Also, some tools such as valgrind can help you detect such errors at run time.

What compiler/debugger are you using? MSVC++ would complain about it and tell you that you write out of bounds of an array. But it is not required to do it by the standard. It can crash anytime, it causes undefined behaviour.

Primitive arrays do not do bounds-checking. If you want bounds-checking, you should use std::vector instead. You are accessing invalid memory after the end of array, and purely by luck it is working.

There is no runtime checking on the index you are giving, accessing element 10 is incorrect but possible. Two things can happen:

if you are "unlucky", this will not crash and will return some data located after your array.
if you are "lucky", the data after the array is not allocated by your program, so access to the requested address is forbidden. This will be detected by the operating system and will produce a "segmentation fault".

There is no rule stateing that the memory access is checked in c, plain and simple. When you ask for an array of bool's it might be faster for the Operating system to give you a 16bit og 32bit array, instead of a 9bit one. This means that you might not even be writing or reading into someone elses space.

C++ is fast, and one of the reasons that it is fast is becaurse there are very few checks on what you are doing, if you ask for some memory, then the programming language will assume that you know what you are doing, and if the operating system does not complain, then everything will run.

There is no problem! You are just accessing memory that you shouldn't access. You get access to memory after the array.

isSeedPos doesn't know how big the array is. It is just a pointer to a position in memory. When you point to isSeepPos[10] the behaviour is undefined. Chances are sooner or later this will cause a segfault, but there is no requirement for a crash, and there is certainly no standard error checking.

Writing to that position is dangerous.

But the compiler will let you do it - Effectively you're writing one-past the last byte of memory assigned to that array = not a good thing.

C++ isn't a lot like many other languages - It assumes that you know what you are doing!

Both C and C++ let you write to arbitrary areas of memory. This is because they originally derived from (and are still used for) low-level programming where you may legitimately want to write to a memory mapped peripheral, or similar, and because it's more efficient to omit bounds checking when the programmer already knows the value will be within (eg. for a loop 0 to N over an array, he/she knows 0 and N are within the bounds, so checking each intermediate value is superfluous).

However, in truth, nowadays you rarely want to do that. If you use the arr[i] syntax, you essentially always want to write to the array declared in arr, and never do anything else. But you still can if you want to.

If you do write to arbitrary memory (as you do in this case) either it will be part of your program, and it will change some other critical data without you knowing (either now, or later when you make a change to the code and have forgotten what you were doing); or it will write to memory not allocated to your program and the OS will shut it down to prevent worse problems.

Nowadays:

Many compilers will spot it if you make an obvious mistake like this one
There are tools which will test if your program writes to unallocated memory
You can and should use std::vector instead, which is there for the 99% of the time you want bounds checking. (Check whether you're using at() or [] to access it)

This is not Java. In C or C++ there is no bounds checking; it's pure luck that you can write to that index.