What are the cases in which the C compiler does not provide an ending null value?

Question

I have been learning C, and coming from more high level languages it definitely is something new! I know that arrays are terminated by a '\0' value, and I was wondering what are the instances in which the compiler does not provide this? For example:

int main() {
    int val;
    scanf("%d", &val);
    char arr[val + 1]; 
    arr[val] = '\0'; // The null value must be stated or something unpredictable occurs  
    for (int i = 0; i < val; i++ ) {
        arr[i] = 'a';
    }
    printf("This is the output:\n%s", arr);

    char arr2[5]; // This works perfectly fine
    for (int i = 0; i < 5; i++ ) {
        arr2[i] = 'a';
    }
    printf("This is the output:\n%s", arr2);
}

So the concept I have been getting is that when we either

1. Dynamically allocate memory or
2. Don't know the size of an array at compile time

is when the compiler can't/doesn't supply the ending null value. If this is the case, are there other cases to be aware of when working with arrays?

EDIT: After being pointed out, arr2 in this sense is not provided an ending zero terminator although it prints what I would expect.

Answer 1

(I'm not sure if this answers your question, but I think it does. If not, tell me to delete it, and l'll do so) The compiler only provides this when you are initializing a literal:

const char str[] = "Hello, world!"

Anytime else (for all intents and purposes I think) the compiler doesn't do this for you. Some functions (inside the standard library and outside) will add a \0 for you, but the best way to figure this out is to look at the documentation.

Answer 2

Arrays are not generally terminated by '\0'

Strings, which are a specific kind of character array, are by definition terminated by '\0'. This means a C-style string is a "char array that is terminated by '\0'. This is true even if:

• The first '\0' is encountered before the end of the allocated "char array"
• The first '\0' is encountered as the last element of the allocated "char array"
• The first '\0' is encountered after the last element of the allocated "char array"

Notice that last one, it causes all sorts of trouble. This means it is up to you as a developer to ensure that you have a '\0' at the end of any strings created while your program runs. A C-style string like "hello" will have its character array end in a '\0' because the compiler will create the backing array and insert that character at the end for you.

Mistakes in developing software include not ensuring that, as you change a string, all your strings end in '\0'. If you write a mistake like that into your code, there is a non-zero chance that some string operation (the non-safe ones) will just keep reading until it happens upon a '\0' or walks out of the program's assigned memory.

The first case can cause a security hole (called injection attack) in addition to incorrect program function. The second case will likely cause your program to terminate with a SEGFAULT message.

Answer 3

I know that arrays are terminated by a '\0' value,

No, strings are terminated by a zero byte (which can be expressed as '\0'). This is, in fact, among the defining characteristics of strings. But in C, strings are data, not a data structure. There is no "string" data type, and although the distinction is a bit fine, the array containing a string is not the same thing as that string itself. Among other things, it may be that the array is larger than the string contents + terminator. Arrays are not guaranteed to be terminated by any special value, except inasmuch as their contents may dictate (the array containing a string literal, for example).

and I was wondering what are the instances in which the compiler does not provide this?

The compiler is responsible for ensuring termination of string literals inside the arrays it automatically provides to contain them. It will also default-initialize otherwise uninitialized arrays declared at file scope or as static, which means initialization to zero for elements of arithmetic type, including character type. It will also default-initialize uninitialized members of any array, including automatic ones, when there is an explicit initializer (not an assignment!) covering only some members. The compiler has no other responsibility for providing zero termination.

For the most part, the string functions of the standard library depend on their inputs to be zero-terminated (that is, to be bona fide strings), and they provide zero-terminated output strings. But there are exceptions.

Similarly, for the most part, I/O functions that accept string inputs expect bona fide zero-terminated strings, and those that provide string outputs ensure zero-termination. But again, there are exceptions.

When it successfully allocates memory, the standard library function calloc() zero-initializes it. malloc() and realloc() do not do this.

That covers most of the standard library functions relevant to the question, I think, but this is something you need to pay attention to. Generally, though, function documentation will be explicit about any cases where the function accepts or produces unterminated "strings".