Accessing and Modifying Structs in C

In C, a union is a special composite data type whose core characteristic lies in the fact that all its members share the same block of memory. Unlike structs, which can store multiple types simultaneously at different offsets, a union stores only one member's data at any given moment. This design makes unions essential tools for handling polymorphic data or performing low-level binary operations. Understanding the memory layout of unions is a prerequisite to mastering their access and modification rules and is key to avoiding undefined behavior.
The way unions are laid out in memory is quite intuitive: all members start from the same base address. The compiler typically determines the total size of the union based on the "largest" member's size to ensure it can accommodate any possible data member. However, because different data types may have varying alignment requirements (Alignment) within memory, a union's actual size is often larger than its theoretical maximum.

For example, if a union contains a 4-byte int and an 8-byte double, although the double occupies more space, the compiler might pad the overall structure according to system architecture constraints to meet the most strict alignment requirements. This padding is determined by either the language standard or the specific compiler implementation; developers should verify the exact size using the sizeof() operator rather than relying on empirical estimation.

Basic Rules for Access and Modification

Since union members share memory, any member's pointer can be used to access or modify its internal data. When one member is written to, the contents of other members are overwritten; conversely, writing to another member overwrites the first. This implies that when operating on a union, it must be explicitly clear which member's data is currently expected, otherwise logical confusion ensues.

The standard way to access union members using struct pointers (or rather, treating them as unions) looks like this:

#include <stdio.h>

union Data {
    int i;
    float f;
    char c;
};

int main() {
    union Data u;
    
    // Assign value via the 'int' member
    u.i = 42;
    printf("Integer form: %d\n", u.i);
    
    // Read via the 'float' member (memory is currently covered by int)
    printf("Float form: %f\n", u.f);
    
    return 0;
}

The code above demonstrates the mutual overwriting characteristic between union members. It is worth noting that while indirect access can be achieved through pointers, when assigning directly to a union variable, the compiler treats it as writing the entire block of memory into the address space. The specific impact on which member depends entirely on the target address and type size of the write operation.

Common Pitfalls and Undefined Behavior

In practical development, developers often fall into two main misconceptions: first, mistakenly believing that a union can store multiple values simultaneously; second, ignoring interpretation errors caused by binary representation differences between members.

Firstly, a union cannot hold more than one valid data value at the same time. Once data is written to any member, the contents of other members are corrupted. Secondly, because int, float, and char have completely different encoding formats in memory (such as two's complement or IEEE 754 floating-point standards), directly reading a numeric value from one member into another often yields meaningless results, potentially triggering undefined behavior.

For instance, storing the integer 1 into a union and then printing it as a float typically does not output 1.0, but rather interprets that integer's binary bits in memory to form a floating-point value. This "garbage" phenomenon is one of the most typical characteristics of unions and represents an error frequently made by beginners.

Practical Application Scenarios and Best Practices

Although unions are often used to simulate polymorphic behavior or for hardware register operations, in modern C programming they appear more commonly in system-level development, embedded programming, and scenarios requiring efficient memory management.

To safely leverage unions, the following best practices should be followed:

  • Always use pointers for access: Avoid assigning values directly via member names and then reading across types; instead, operate uniformly using union *p forms.
  • Explicitly identify the current valid member: Clearly mark which member is currently being operated on within code logic to prevent misreading data that has been overwritten.
  • Combine with bit-fields where appropriate: For scenarios requiring fine-grained control over memory bits, unions can be combined with bit-fields to achieve more compact data encapsulation.
union BitField {
    unsigned int value;
    struct {
        unsigned int : 4; // Reserved bits
        unsigned int flag1: 1;
        unsigned int flag2: 1;
        unsigned int : 3;
    } bits;
};

int main() {
    union BitField u;
    u.bits.flag1 = 1;
    printf("Flag bit set\n");
    return 0;
}

Summary

Unions are a powerful and flexible data structure in C, with their core advantage lying in the efficient utilization of memory and unified storage for polymorphic data. However, this flexibility comes at the cost of higher usage thresholds. Developers must deeply understand the essence of shared memory within unions, strictly adhere to access rules, and remain vigilant against undefined behavior caused by type misinterpretation. By reasonably utilizing pointers, explicitly defining data states, and combining advanced features like bit-fields, unions can become powerful tools for building high-performance, low-overhead systems.