Lets imagine you're defining a structure Img to manipulate images. Among the properties of Img there will be the dimensions of the image. This is very probably an array of two integers, something like: int dims[2]. Then comes the question, is this dims = {width, height} or dims = {height, width} ? If you don't mind, you'll use numerical indices, 0 and 1, and will, yes you will, mix them up one day or the other. So, to prevent that, you can define a macro or enumeration like #define width 0 and #define height 1, promise yourself to always use them, and pollute the name space happily. Else, you could avoid using one single array and use two properties instead: int width; and int height;. Much safer, but if you want to pass the two dimensions at once you can't anymore, that's going to make interface of functions heavier. So you may think of defining another structure struct Dimension {int width; int height;}; and use it as: struct Img {struct Dimension dims;} theImg;. Now you can access each dimension explicitly or pass them both at once when necessary. Using a struct hides the fact that the dimension are still a block of two integers in memory. Of course you can still express it by casting: (int*)&(theImg.dims) which is a bit lengthy isn't it?

Thanks to anonymous unions you can go one step further and improve on readability, by writing Img as follow:

struct Img { union { int dims[2]; struct {int width; int height;}; } };

Thanks to automatic promotion of dims, width and height at the struct Img scope thanks to the anonymous union and struct, they can be accessed directly as theImg.dims, theImg.width and theImg.height while being the same data in memory. One can manipulate them as int* or two int as necessary. If you wish to manipulate as the union, the preprocessor will help you solve a little problem: for the redirection to works the union must be declared inside Img. You can't write:

typedef union { int dims[2]; struct {int width; int height;}; } Dimension; struct Img { Dimension; };

and use Dimension later. You could write the union declaration twice:

typedef union { int dims[2]; struct {int width; int height;}; } Dimension; struct Img { union { int dims[2]; struct {int width; int height;}; }; };

Awful code duplication, you're guaranted to forget to update one of the declarations the day it will change. Using the preprocessor instead avoid any trouble:

#define Dimension_ \ union { \ int dims[2]; \ struct {int width; int height;}; \ } typedef Dimension_ Dimension; struct Img { Dimension_; };

No cast, as short as you can get, available as union, int* and two int. Bingo!

Finally, a complete example to test:

#include <stdio.h> #define UnionDimension_ \ union { \ int dims[2]; \ struct {int width; int height;}; \ } typedef UnionDimension_ UnionDimension; struct Img { UnionDimension_; }; int main() { struct Img a = {.dims = {1, 2}}; printf("%d %d\n", a.width, a.height); struct Img b = {.width = 3, .height = 4}; printf("%d %d\n", b.dims[0], b.dims[1]); UnionDimension theDims = {.dims = {5, 6}}; struct Img c = {.width = theDims.dims[0], .height = theDims.dims[1]}; printf("%d %d\n", c.dims[0], c.dims[1]); } // Compile with: // gcc -std=c18 -Wall -Wextra -o main main.c // Outputs: // 1 2 // 3 4 // 5 6

Edit on 2022/11/28: Note that you have to take care of eventual padding in the inner struct of the union ! If needed protect it with __attribute__((packed)).