Is it legal to read into an array that doesn't have space for the null terminator?

user_16503383 0
Viewed 135

Every C string is terminated with the null character when it is stored in a C-string variable, and this always consumes one array position.

So why is this legal:

char name[3];
std::cin >> name;

when a 3 letter word "cow" is input to std::cin?

Why is it allowing this?

c++
3 Answers

The compiler cannot know what input you will be giving at runtime, so it cannot say that you will be doing something illegal. If the input fits in the array, then it's legal.

Prior C++20:

The behaviour of the program is undefined. Never do this.

Since C++20:

The input will be truncated to fit into the array, so the array will contain the string "co".

user_20793030

It is allowed because the memory management is left to the programmer. In this case the error occurs at run-time and it's impossible for the compiler to spot it at compile time.

What you are getting here is an undefined behavior, where the program can crash, can go on smoothly, or present some odd behavior in the future.

Most likely here you are overflowing the allocated memory by one byte which will be stored in the first byte of the subsequent declared variable, or in other addresses which may or may not be already filled with relevant information.

You eventually may experience an abort of the execution if - for example - some read-only memory area is overwritten, or if you point your Instruction Pointer to some invalid area (again, by overwriting its value in memory)

user_16545260

Depends what you mean by "legal". In context of your question, there is no precise meaning.

According to the standard (at least before C++20) your code (if supplied with that input) has undefined behaviour. When behaviour is undefined, any observable outcome is permitted, and no diagnostics are required.

In particular, there is no requirement that an implementation (the compiler, the host system, or anything else) diagnose a problem (e.g. issue an error message), take preventative action (e.g. electrocute the programmer for entering "cow" before hitting the enter key), or take recovery action (e.g. truncate the input to "co").

The reason the standard allows such things is a combination of;

  • allowing implementation freedoms. For example, the standard permits but does not require your host system to electrocute the user for entering bad input to your program - but doesn't prevent an evil-minded system developer providing hardware and driver support to do exactly that;
  • technical infeasibility or technical difficulty. In a simple case like your code might be easy to detect. But, in more complicated programs (e.g. your code is buried away among other code) it might be impossible to identify a problem. Or, it might be possible, but take much longer than a programmer is willing/able to spend waiting.

In short, the C++ standard does not coddle the programmer. The programmer - not the standard, not the compiler - is responsible for avoiding undefined behaviour, and responsible if a program with undefined behaviour does undesirable things.

user_47067850
Related