How to read this C Array declaration/intialization?

Question

char *names[] = {
        [3] = "foo", 
        [1] = "bar", 
        [0] = "man"};

int i;
for (i=0; i<sizeof(names)/sizeof(char); i++)
{
    puts(names[i]);
}

What are the function of the brackets in the above declaration? Also, why does the resulting loop iterate 3 times instead of 4 and produce this output:

man

bar

Answer 1

The numbers in brackets are the indices of the initializers. This is a C99 feature.

Given that your example code does use this blemish, the reason you receive the output you do is that "foo" is stored in names[3], while NULL is stored in names[2]. Your program crashes when it attempts to puts(names[2]) which is the same as puts(NULL).

Your loop would otherwise iterate to 16 or 32 iterations -- you are dividing by sizeof(char) for the array element size, and you mean to use sizeof(char *).

Better to use this macro:

#define DIMENSION_OF (a) (sizeof(a)/sizeof(a[0]))

I suggest never using any C99-specific features, such as these "designated initializers."

There is a reason that most of the answers you received on this question were confused as to why your loop only output two strings rather than four. That reason is that C99 is not widely recognized by other programmers.

There are several reasons that most programmers aren't familiar with C99's more distinctive features. A frequently cited reason is that C99 is more incompatible with C++ than ANSI C, and makes the possibility of future conversion to C++ more difficult. My personal complaint with C99 also makes extensions to ANSI C which are superfluous. An example of a superfluous addition is the example from C99 that you have provided. Don't use "designated inits." Do refer to the American National Standards Institute C Standard. Do not refer to the International Standards Organization C99 document.

Most of the features which are "nice to have" form C99 were already available as extensions in all major compilers. Declaring a variable in the for-init-statement is an example of a non-ANSI-C-standard feature which is widely supported. The complex built-in type is an example of a non-ANSI-C-standard feature that is not widely supported.

Answer 2

The following definition shows how you can use designated initializers to skip over elements of the array that you don't want to initialize explicitly:

static int number[3] = { [0] = 5, [2] = 7 };

The array number contains the following values: number[0] is 5; number[1] is implicitly initialized to 0; number[2] is 7.

Heath below, describes the effect of your for loop, so I will not repeat.

Answer 3

It declares names to be an array (whose size is determined by the compiler) of pointers to char, with initialization that also determines the size of the array; the initialization "decides" explicitly the index of specific pointer; e.g. man is at index 0, foo at index 3... The final size is given by the bigger index, and all values with indexes not explicitly given are set to null.

It should be sizeof(char *) as already said. The loop prints the content; if the number of elements in the array is 3, the index must go from 0 to 2, (2<3 but 3<3 is false) since index-base in C is 0.