The Concept and Characteristics of a Union

In the type system of the C language, a union is a special variant of a structure whose core characteristic lies in the fact that all its members share the same contiguous block of memory. This stands in stark contrast to structures, where each member occupies its own dedicated portion of memory. The primary use case for unions is to allow programs to store different primitive data types at a specific storage address, thereby enabling flexible management of heterogeneous data.

From a low-level perspective, when the compiler encounters a union definition, it calculates the byte length of its largest member as the size of the entire union. This means that regardless of which member the current variable actually stores, the total capacity of this memory block must be sufficient to hold the largest data item within it. This design gives unions a unique advantage in terms of space saving, making them particularly suitable for scenarios involving binary data processing, hardware register values, or raw network protocol packets.
The declaration method for unions is similar to that of structures, but with a different keyword. The standard format is as follows:

typedef struct {
    int member1;
    char member2[5];
} MyUnion;

In C99 and later versions, the union keyword can also be used directly for definition:

union Data {
    float f_val;
    double d_val;
};

When using unions, one must pay attention to initialization rules. Unlike structures, where all members are initialized by default, union members are not all initialized but become effective only after being explicitly assigned by the program. In the C89/C90 standards, uninitialized union members contain random garbage values; whereas in C99 and subsequent versions, although convenience for default initialization is provided (e.g., union u = {1};), developers must still be explicitly aware of which member is currently active.

Memory Layout and Type Conversion Mechanism

The key to understanding unions lies in mastering their memory sharing characteristic. Assume the following union is defined:

union Example {
    int i;      // 4 bytes
    char c[3];   // 3 bytes
};

The total size of this union is 4 bytes because int is the largest member within it. When an integer is assigned to the variable:

union Example u;
u.i = 1024;      // int is written into memory address [addr]~[addr+3]
printf("%d\n", u.c);   // Output result depends on how char interprets these 4 bytes

At this point, char c[3] occupies the first three bytes (or the last three bytes, depending on the compiler's alignment strategy), while the fourth byte may contain unused space. Attempting to access different members is essentially performing a different type interpretation on the same block of memory. This mechanism is similar to pointer type conversion: after forcibly converting int* to char*, data can be read byte by byte, and unions provide a more secure encapsulation method for this operation.

Practical Application Cases and Precautions

Typical application scenarios for unions include raw packet parsing in network programming, hardware register mapping in embedded systems, and low-level processing of multimedia data. The following is a complete example code demonstrating its usage:

#include <stdio.h>

union Packet {
    unsigned char bytes[4];      // Byte array form
    struct {                      // Structure form (still shares memory internally)
        unsigned int magic;       // Magic number identifier
        short version;            // Version number
    } header;
};

int main() {
    union Packet pkt = {.bytes = {0x12, 0x34, 0x56, 0x78}};
    
    printf("Byte view: ");
    for (int i = 0; i < 4; i++) {
        printf("%02X ", pkt.bytes[i]);
    }
    printf("\n");
    
    // Interpret the byte array as structure data
    unsigned int magic_val = ((unsigned char)pkt.bytes[1] << 8) | 
                              (unsigned char)pkt.bytes[3];
    
    return 0;
}

In practical usage, developers must pay attention to the following key points: first, the type size of union members determines the upper limit of memory occupation; second, integer alignment rules may vary across different architectures, potentially leading to differences in actual storage layout; and finally, when porting across platforms, one must consider the return value of sizeof(). Furthermore, since all members share the same address space, misoperating on one member may compromise the integrity of others; therefore, it is imperative to verify the currently active member status before use.

Summary and Best Practice Recommendations

As a powerful and flexible data organization tool in the C language, the core value of unions lies in breaking down the memory isolation limits between different data types. By reasonably utilizing unions, developers can achieve conversion and shared storage of multiple data formats without incurring additional overhead. However, due to its inherent "ambiguity," improper use may lead to low-level errors that are difficult to debug.

It is recommended to follow these principles in actual projects: clearly annotate the type of the currently used member; test memory layout behaviors across different compilers in cross-platform code; avoid using unions for critical business logic requiring strict type safety; and prioritize structures for compositional encapsulation, enabling union mechanisms only when binary interoperability is genuinely required. Mastering the essence of unions will elevate your C programming skills from basic application to system-level development.