Union Initialization

Union initialization is the process of assigning an initial value to a union variable at the time of its declaration. Because a union allocates overlapping memory for all its members, it can only store one member’s value at any given time. Consequently, a union can only be initialized with a single value corresponding to exactly one of its members.

There are four primary mechanisms for initializing a union in C.

1. First-Member Initialization (Traditional)

If a union is initialized using a brace-enclosed list without explicit designators, the compiler strictly applies the value to the first declared member of the union. The type of the provided value must be compatible with the type of the first member. According to the C standard (C17 §6.2.6.1p7), when a value is stored in a union member, the bytes of the object representation that do not correspond to that member take unspecified values.

union Data {
    int i;
    float f;
    char str[20];
};

// Initializes the first member (int i) with 10.
// The integer occupies the first bytes; the remaining bytes of the 20-byte union take unspecified values.
union Data val = { 10 }; 

2. Designated Initializers (C99 Standard)

Introduced in C99, designated initializers allow explicit specification of which union member is being initialized by using the dot (.) operator. This approach is type-safe and independent of member declaration order. Similar to first-member initialization, any bytes of the union’s object representation that do not correspond to the designated member take unspecified values.

union Data {
    int i;
    float f;
    char str[20];
};

// Explicitly initializes the float member 'f'.
union Data val_float = { .f = 3.14159f };

// Explicitly initializes the string array member 'str'.
union Data val_string = { .str = "Hello" };

3. Zero Initialization

A union can be initialized by providing a single 0 inside the braces. The compiler applies the zero value to the first named member. As with other initialization methods, the bytes of the union that do not correspond to the first member take unspecified values; they are not implicitly zero-initialized.

union Data {
    int i;
    float f;
    char str[20];
};

// Initializes 'i' to 0. The remaining bytes of the union take unspecified values.
union Data val_zero = { 0 }; 

Note: In C23, empty braces {} are strictly standardized for zero initialization of the first member.

4. Copy Initialization

A union can be initialized using an existing union variable, provided both variables are of the exact same union type. This performs a direct memory copy of the entire object representation (i.e., sizeof(union Data) bytes). The C compiler does not track the “active member” at runtime, so the full allocated size is copied regardless of which member is currently active or how large that active member is.

union Data {
    int i;
    float f;
    char str[20];
};

union Data original = { .f = 9.81f };

// Initializes 'copy' by duplicating the entire sizeof(union Data) memory state of 'original'.
union Data copy = original; 

Initialization Constraints

• Single Value: Multiple members of a union cannot be initialized simultaneously. Attempting to provide multiple comma-separated values in a brace-enclosed list (e.g., { 10, 3.14f }) will result in a compiler warning or error.
• Static/Global Unions: If a union has static storage duration (declared globally or with the static keyword) and is not explicitly initialized, the C standard dictates that the first named member is initialized to zero (or null for pointers) and any padding is initialized to zero bits. However, bytes belonging to other larger members are not strictly defined as padding. Therefore, the standard does not guarantee that the entire memory block of the union is zeroed.

Master C with Deep Grasping Methodology!

Learn More