Cryptic struct definition in C

Question

I came across the following maze definition code:

typedef struct mazeNode {
    int hasCheese;
    int tag;
    struct mazeNode *left;
    struct mazeNode *right;
} maze_t;

maze_t maze = {
    .tag = 1,
    .left = &(maze_t) {
        .left = &(maze_t) {
            .left = &(maze_t) {},
            .right = &(maze_t) {}
        },
        .right = &(maze_t) {
            .right = &(maze_t) {}
        }
    },
    .right = &(maze_t) {
        .tag = 8,
        .left = &(maze_t) {},
        .right = &(maze_t) {
            .tag = 10,
            .left = &(maze_t) {
                .tag = 11,
                .left = &(maze_t) {
                    .hasCheese = 1,
                    .tag = 12
                }
            },
            .right = &(maze_t) {}
        }
    }
};

From the linked blog post I understand that they are trying to define the binary tree with the cheese in the diagram.

However I can't seem to make head or tail out of what the C code is supposed to do. It would be great if someone could explain it to me.

The code presented is accompanied by a [blog post](http://duartes.org/gustavo/blog/post/recursion/) in which the author describes the code. — , Aug 30 '14 at 01:23
They are using [compound literals](http://stackoverflow.com/questions/23294769/initialize-struct-without-an-assignment). — Shafik Yaghmour, Aug 30 '14 at 01:27
The `.left = &(maze_t){};` and `.right = &(maze_t){};` would more naturally be initialized to `0` or `NULL`. As it stands, there is an extra element in the hierarchy with a `.tag` value of `0` and a `.hasCheese` value of `0` too (and null left and right pointers). — Jonathan Leffler, Aug 30 '14 at 02:06

score 10 · Accepted Answer · edited May 23 '17 at 12:09

This code is using a combination of designated initializers and compound literals, which are both C99 features, I linked to other answer where I provide standard quotes for both of these features.

Designated initializers allow you to use specify a specific field to initialize using .fieldname =, an example from the linked document is:

 struct point { int x, y; };

the following initialization

struct point p = { .y = yvalue, .x = xvalue };

is equivalent to

struct point p = { xvalue, yvalue };

The other feature being used is compound literals which is being used to create unnamed static objects and then the code takes the address of this object and assigns it the respective pointers left and right. It then uses this feature recursively within the unnamed objects to set their respective left and right pointers.

 .left = & (maze_t) { .... }
           ^^^^^^^^^^^^^^^^
           unnamed static object

These unnamed objects are only static if they are used outside the body of a function otherwise they will have automatic storage duration and would cease to exist once you exit the function and so taking their addresses like the code is doing would probably be unwise.

For reference I provide a standard quote on compound literals in my answer here.

Important to note that when using designated initializers any field not explicitly initialized will be initialized to zero, which is actually important in this case, for example hasCheese will be set to 0 unless it is specifically set otherwise.

Although these are C99 features not all compilers support or fully support C99, my tests on Visual Studio show that we need to replace the empty compound literals, for example:

left = &(maze_t) {}

with a NULL to get it to compile. I filed a bug report.

The response to the bug report was as follows, but basically this is a gcc/clang extension at work:

This is a GNU extension. Clang supports it as an extension (see the clang option -Wgnu-empty-initializer).

The standard way to write this is {0}, which will zero initialize all fields.

is this standard feature across all platforms.Or does using such features affect portabiliy? — liv2hak, Aug 30 '14 at 09:29
@liv2hak They are both C99 features and so both `gcc` and `clang` support them. Visual Studio recently started supporting C99 features but I am not totally sure how well supported these features are. — Shafik Yaghmour, Aug 30 '14 at 12:58
@liv2hak ok, Visual Studio does not like the code as is, so not fully portable. — Shafik Yaghmour, Sep 01 '14 at 00:42
Thought I should make a note here that this is not a bug in Visual Studio as empty compound literals are actually a GNU extension which you can see with `-pedantic` enabled `warning: use of GNU empty initializer extension [-Wgnu-empty-initializer]`. The standard way to initialise all fields to zero is `{0}`. — sjdowling, Sep 18 '15 at 15:15
@sjdowling thank you, I thought I updated this question when I received the bug report response. Clearly I did not, let me do that now. — Shafik Yaghmour, Sep 18 '15 at 15:27

score 3 · Answer 2 · answered Aug 30 '14 at 01:48

The code is initializing a struct according to a syntax allowed in the C since 1999 (C99 and C11).

Briefly explained, you can initialize a struct variable by writting only the "members" of the struct enclosed in braces { }.

For example, given the following struct:

 struct fractional_number_s { int numerator; unsigned int denominator; };

we can define and initialize struct variables as follows:

 struct fractional_number_s r = { .numerator = 3, .denominator = 7, };

As you can see, it's enough to write the members, without the variable-name r.
This syntax is allowed in initializers.

Also, in normal assignments we can have a similar syntax with the aid of compound literals, as in this example:

 r = (struct fractional_numbers_s) { .numerator = 3, .denominator = 7 };

Search on internet about these topics: C struct initializers and C compound literals, to obtain more information (technical note: ANSI C89 doesn't have this syntax, so search for ISO C99 and ISO C11).

Cryptic struct definition in C

2 Answers2

Linked