When are anonymous structs and unions useful in C11?

Anonymous union inside structures are very useful in practice. Consider that you want to implement a discriminated sum type (or tagged union), an aggregate with a boolean and either a float or a char* (i.e. a string), depending upon the boolean flag. With C11 you should be able to code

typedef struct {    bool is_float;    union {       float f;       char* s;    };} mychoice_t;double as_float(mychoice_t* ch) {    if (ch->is_float) return ch->f;   else return atof(ch->s);}

With C99, you'll have to name the union, and code ch->u.f and ch->u.s which is less readable and more verbose.

Another way to implement some tagged union type is to use casts. The Ocaml runtime gives a lot of examples.

The SBCL implementation of Common Lisp does use some union to implement tagged union types. And GNU make also uses them.

A typical and real world use of anonymous structs and unions are to provide an alternative view to data. For example when implementing a 3D point type:

typedef struct {    union{        struct{            double x;             double y;            double z;        };        double raw[3];    };}vec3d_t;vec3d_t v;v.x = 4.0;v.raw[1] = 3.0; // Equivalent to v.y = 3.0v.z = 2.0;

This is useful if you interface to code that expects a 3D vector as a pointer to three doubles. Instead of doing f(&v.x) which is ugly, you can do f(v.raw) which makes your intent clear.

struct bla {    struct { int a; int b; };    int c;};

the type struct bla has a member of a C11 anonymous structure type.

struct { int a; int b; } has no tag and the object has no name: it is an anonymous structure type.

You can access the members of the anonymous structure this way:

struct bla myobject;myobject.a = 1;  // a is a member of the anonymous structure inside struct bla   myobject.b = 2;  // same for bmyobject.c = 3;  // c is a member of the structure struct bla