5.20 Compound Literals

ISO C99 supports compound literals. A compound literal looks like
a cast containing an initializer. Its value is an object of the
type specified in the cast, containing the elements specified in
the initializer; it is an lvalue. As an extension, GCC supports
compound literals in C89 mode and in C++.

Usually, the specified type is a structure. Assume that
struct foo and structure are declared as shown:

struct foo {int a; char b[2];} structure;

Here is an example of constructing a struct foo with a compound literal:

structure = ((struct foo) {x + y, 'a', 0});

This is equivalent to writing the following:

{
struct foo temp = {x + y, 'a', 0};
structure = temp;
}

You can also construct an array. If all the elements of the compound literal
are (made up of) simple constant expressions, suitable for use in
initializers of objects of static storage duration, then the compound
literal can be coerced to a pointer to its first element and used in
such an initializer, as shown here:

char **foo = (char *[]) { "x", "y", "z" };

Compound literals for scalar types and union types are is
also allowed, but then the compound literal is equivalent
to a cast.

As a GNU extension, GCC allows initialization of objects with static storage
duration by compound literals (which is not possible in ISO C99, because
the initializer is not a constant).
It is handled as if the object was initialized only with the bracket
enclosed list if compound literal's and object types match.
The initializer list of the compound literal must be constant.
If the object being initialized has array type of unknown size, the size is
determined by compound literal size.