Declaration and Initialization of Structures

In memory management within the C language, structs are used to combine variables of different data types together, while unions serve as their complementary form. Unions allow storing single values of different data types in the same block of memory space; this is extremely common in embedded development, hardware description, and application scenarios requiring efficient utilization of storage space. Understanding the declaration and initialization rules for unions is a crucial step toward mastering low-level features of C.
A union is a special user-defined type whose core characteristic lies in all members sharing the same memory address. This means that at any given moment, only one data type's value can be stored within a union; other unassigned members will remain in their initial state (typically all zeros). Unlike structs, unions do not require explicit initialization of every field to use them; as long as you write into one member variable, the contents of the union are considered valid for access.

This design allows developers to dynamically adjust memory layouts based on the actual data type being used, thereby achieving extreme space utilization in environments with specific hardware resource constraints. For example, during a register operation, we might only need to read byte-level data; defining it as a struct and initializing all fields would waste significant space, whereas using a union allows for precise matching of requirements.

Declaration Syntax Specifications for Unions

When defining a union, the union keyword must be followed by a type name. Each member can be declared with any valid C language data type, including basic types (such as int, char) or complex types like custom structs and pointers. It is important to note that while theoretically arbitrary types of members can be included, compilers typically issue warnings or impose restrictions on certain specific combinations, particularly regarding non-aligned access scenarios.

Here is a standard example of union declaration:

union Data {
    int i;      // Integer mode
    float f;    // Floating-point mode
    char c[4];  // Character array mode (max size 3+1)
} data;

In the code above, Data is the name of the union. Regardless of whether you use data.i, data.f, or data.c, they all point to the same memory region. When accessing one member, the compiler automatically calculates its position in memory based on that member's offset, but logically all members share a starting address.

Initialization and Assignment Operation Rules

Unions do not require explicit initialization at definition time like structs (unless using compound literals), as their behavior depends on data written during runtime. As long as one of the union's members is assigned a non-zero or non-empty value, the state of the union is considered valid. It is worth noting that accessing an unused member leads to undefined behavior (Undefined Behavior).

To clearly demonstrate assignment processes, we can refer to the following example:

#include <stdio.h>

int main() {
    union Data data;

    // Initialize integer member
    data.i = 42;
    
    printf("Integer value: %d\n", data.i);
    
    // Convert integer value to floating-point value (memory content remains unchanged, only interpretation changes)
    data.f = (float)data.i; 
    printf("Float value: %.2f\n", data.f);

    return 0;
}

In this example, after storing the integer 42 into the union, we output it as a floating-point number via an explicit type cast. Since all members share memory, this "reinterpretation cast" operation is safe at the lower level, provided that the bit width of the target type does not exceed the maximum member's bit width within the union and no overflow or truncation errors occur.

Precautions and Best Practices for Unions

In practical development, special attention must be paid to the following points when using unions to avoid potential pitfalls:

• Memory Alignment Issues: Different data types may have different byte alignment requirements (Alignment). When a union contains multiple members, its total size is typically equal to the number of bytes in the largest member plus necessary padding bytes to satisfy the most stringent alignment requirement. This can cause certain small type combinations to occupy more actual space than expected.
• Undefined Behavior Risks: Do not write values for two different types' members and then read a third member's value unless you are sure that the previous two write operations will not destroy the valid data bit patterns of the latter (which is impossible in most cases).
• Debugging Difficulty: Due to the transparent internal structure and shared memory of unions, accessing an incorrect type when printing with printf can lead to completely erroneous output results. It is recommended to add assertions or log checks on critical paths regarding the current state of used members.

By reasonably utilizing union declaration and initialization mechanisms, developers can achieve fine-grained control over underlying hardware resources while ensuring code logic correctness; this represents one important aspect of advanced C programming capabilities.