C - Uninitialized pointer -> pointing to an array

Question

I have a question to the following code:

#include <stdio.h>

int main() {
    int i;

    char char_array[5] = "abcde";
    int int_array[5] = {1, 2, 3, 4, 5};

    char *char_pointer;
    int *int_pointer;

    for(i=0; i < 5; i++) {
        printf("[integer pointer] points to %p, which contains the integer %d\n", int_pointer, *int_pointer);
        int_pointer = int_pointer + 1;
    }

    for(i=0; i < 5; i++) {
        printf("[char pointer] points to %p, which contains the char '%c'\n", char_pointer, *char_pointer);
        char_pointer = char_pointer + 1;
    }
}

I didn´t initialized any pointer, just set the pointer´s type. These two pointers are pointing to the right memory address of the array and starts at position [0].

Using Ubuntu 7.04 with gcc compiler.

If I run the code i get these results:

[integer pointer] points to 0xbffff7f0, which contains the integer 1
[integer pointer] points to 0xbffff7f4, which contains the integer 2
[integer pointer] points to 0xbffff7f8, which contains the integer 3
[integer pointer] points to 0xbffff7fc, which contains the integer 4
[integer pointer] points to 0xbffff800, which contains the integer 5
[char pointer] points to 0xbffff810, which contains the char 'a'
[char pointer] points to 0xbffff811, which contains the char 'b'
[char pointer] points to 0xbffff812, which contains the char 'c'
[char pointer] points to 0xbffff813, which contains the char 'd'
[char pointer] points to 0xbffff814, which contains the char 'e'

I know it is not the correct programming style and you should not let the pointers uninitialized, nonetheless I came across this and want to ask you, why does the pointer know to which address he has to point without initializing.

Also I put two more arrays into the code int_array2 and char_array2, first after int_array/char_array and second before int_array/char_array. But I still get the same results...

Maybe someone knows the magic behind this. Thanks in advance for taking your time to answer my question.

Answer 1

First, as you might know, this behavior is called undefined behavior in the standard.

From standard perspective, this program might remove your entire hard disk, launch nuclear missiles, or send your boss a very bad mail. However, usually it ends up in program failure.

Now back to your case - I think that it happened because one or more of this options:

1. Your compiler groups memory of variables by types.
2. Your compiler groups memory of variables by alignment size.

Now it still not good reasons, but maybe this grouping is because unnecessary line in the compiler code when variable isn't initialized. It may be possible that this variable of the compiler is uninitialized too :-)

Answer 2

When a local variable is uninitialized, the contents of those variables is undefined.

That means the contents of those variables cannot be predicted. Attempting to read them might output something unexpected, or might appear to work. In the case of pointer variables, dereferencing will typically cause a core dump, but not necessarily.

That's why it's important to always initialize your variables before attempting to read (or dereference) them.

An example of how using uninitialized variables can come back to bite you is OpenSSL. They intentionally leave certain variables undefined as a source of randomness. But someone unfamiliar with the code later ran Valgrind on it, which reported the "issue". The "bug" was then fixed, which caused the random number generator to break. You can find more details here.