Array of pointer declaration

The declaration

int* int_arrays[2] 

declares the variable int_arrays to be an array of two pointers to int. And you initialize the array to contain two pointers to int in the "it works" code. Remember that arrays naturally decays to pointers to their first element, so for example an array of int can be used where int * is expected.

However, you can't use an array initializer list (like { 5, 4, 2}) as a pointer, because it's not. That's why the code you have commented out doesn't build. You could use an array of arrays instead when declaring it, because that's how you initialize it:

char int_array_of_arrays[2][3] = { ... }; 

An important not about the array of arrays, and the decaying of arrays to pointers: An array of arrays is not the same as a pointer to pointer.

As for the "garbage" problem, it's because you try to print the third element of an array containing only two elements. C doesn't have any bounds checking, if you try to index an array out of bounds you will have undefined behavior.

Consider the first declaration

int* int_arrays[2] = {array, array2}; 

Here is the initilaizer list contains two expressions that represent array names. Arrays used in expressions are implicitly converted to pointers to their first elements.

In fact this declaration is equivalent to the following

int* int_arrays[2] = { &array[0], &array2[0] }; 

Take into account that int_arrays is declared as an array with two elements and consequently two initializers are used to initialize the elements of the array.

You can use initializer list with more than one initializer to initialize aggregates: arrays and structure.

If you are using a scalar value than the corresponding initializer list may have only one initializer. Consider

int x = { 10 }; // Okey int y = ( 10, 20 }; // compiler error 

Now consider this declaration

int* int_arrays2[2] = { {5, 4, 2}, {6, 8} }; 

In this declaration the array int_arrays2 as before contains only two elements. Each element of the array is a scalar object of type int *. The initialization avove semantically equivalent to the following

int *p1 = {5, 4, 2}; int *p2 = {6, 8}; 

where p1 and p2 correspond to int_arrays2[0] and int_arrays2[1].

They are scalar objects and as it has been pointed out above may be initialized only by an initializer list with one initializer.

So the compiler issues an error.

On the other hand instead of this wrong declaration you could write

int* int_arrays2[2] = { ( int[] ){5, 4, 2}, ( int [] ){6, 8} }; 

Here is used so-called compound literals that create unnamed arrays of the specified types. So in the left side there is an array of two elements and in the right side there is an initializer list with two initializers, compound literals, that are converted to pointers to the first elements of the created unnamed arrays.

Such an initialization is correct.