Thread: Array Lengths

Originally Posted by SCRIPT_KITTEH

I wonder what will happen if I exceed the array length?

You are in the realm of undefined behaviour. It so happens that it "works" for you with the input that you tested with, but say, if you enter longer input, or if your program was more complex, or if you compile it on a different system, with a different compiler, or with different compiler flags, you might get some kind of error.

For example, I enter all the letters of the English alphabet, in lowercase, as the "name", and your program crashed for me. Or, I changed your program to:

Code:

#include <stdio.h>
 
int main(void) {
    char greeting[] = "Hi";
    char name[3];

    printf("\nWhat's your name?\n");
    scanf("%s", name);

    printf("\n%s, %s.\n", greeting, name);

    return 0;
}

Then entered "Benjamin", and got this output:

Code:

jamin, Benjamin.

1) An array does not have to have a "null character" at the end. Arrays have two properties: the type of the elements, and the length. So "int x[3];" specifies that x as an array of three ints.

2) By convention, a string literal (such as "Hello") is represented in the form of an array of char, with a zero sentinel at the end. So "Hello" is represented as an array of 6 chars, with values 'H', 'e', l', 'l', 'o', and zero. A character with value zero is also equivalent to '\0' (the \xxx as a char constant treats xxx as a hex value). All functions in C that work with strings (strcpy(), strcmp(), strlen(), etc etc) adhere to this convention (for example, strlen() keeps counting characters until it finds one with value zero). A convention is not a law of nature.

3) This convention is specific to arrays of chars and strings. It is not applicable to other types. So an array of int is not guaranteed to have a zero at the end.

4) When the length of any array is exceeded - i.e. an element is accessed outside array bounds - the result is simply undefined behaviour according to the standard. If writing past the end of an array, the result is writing to memory (which might not even exist) that doesn't belong to an array. The consequences of that are undefined (anything is allowed to happen). "Anything" is pretty far reaching. It can include the code appearing to behave sensibly. It can include writing garbage. It can include reformatting your hard drive. Whatever happens, the behaviour is correct - and the compiler is not required to emit a diagnostic. It is the code that exhibits undefined behaviour which is incorrect.

5) It might look to you that you were able to fit more than three characters into a three-character array. That is an incorrect observation. What is actually happening is that there is some memory allocated after the array that is being overwritten by the scanf() call. That memory is not even guaranteed to exist as far as the program is concerned. A host operating system might detect that behaviour and terminate your program. The code might overwrite some other memory used by your program (for example, allocated to variables in other functions). The result is completely unpredictable. If the program has not been forceably terminated during the call of scanf(), the printf() call simply starts printing each character in the array name, and attempts to keep going until it finds a character with value zero. Again, the behaviour is completely unpredictable.

> here name is a pointer,
An array name is not a pointer.
Arrays and Pointers

Slight correction: it's treated as an octal value.

O_o

You "corrected" it from being right to being wrong.

You can use '\nnn' for octal, but '\xxx' is hexadecimal.

The 'x' makes all the difference.

Soma

clarity

O_o

My cranial parasites tell me I could not possibly have been clearer.

Soma

^_^

Yes. I appreciate the likely confusion.

My comment was a joke and a reference to: Maggots - Limbo Wiki from near "news" Middle school warns snorting Smarties may lead to nasal maggots - CBS News

Soma

Originally Posted by phantomotap

Yes. I appreciate the likely confusion.

As do I, the one who caused excessive likelihood of confusion in this case through quick typing (my fingers didn't faithfully capture what I intended).

nonoob was right in spotting my mistake, as were subsequent posts pointing out he made a slight error too.

To be clear (and recap the corrections, and corrections of corrections ....) an octal character value is in the form of \nnn where each n indicates an octal (base 8) digit. So '\0' (equivalent to '\000' is a character with value zero, '\10' is a character with value 8. Similarly, a hex constant is indicated by the escape sequence \xhh where x is the letter x, and the h's represent hexadecimal (base 16) digits. So '\xE0' is a character with value 0xE0 (with decimal value 224 = 14*16).