Table of Contents

Introduction

Structures and unions are the two fundamental aggregate types in C, each designed to group multiple data types under a single identifier. Despite syntactic similarities, they serve opposite semantic purposes. A structure allocates independent storage for every member, enabling simultaneous access to all fields. A union overlays all members in the same memory region, allowing only one field to hold valid data at any given time. This architectural distinction dictates memory footprint, access patterns, lifetime management, and appropriate use cases. Understanding their layout rules, standard compliance requirements, and interaction with compiler optimizations is essential for writing memory-efficient, type-safe, and portable C systems.

Memory Layout and Size Determination

The compiler applies fundamentally different layout algorithms for structures and unions, directly impacting binary size and alignment guarantees.

Structure layout follows sequential placement:

Members are allocated in declaration order
Padding is inserted between fields to satisfy individual alignment requirements
Trailing padding ensures the total size is a multiple of the structure maximum alignment
sizeof returns the sum of all field sizes plus padding bytes

Union layout follows overlapping placement:

All members share the same base address (offset zero)
Size equals the size of the largest member, padded to satisfy the strictest alignment requirement among all members
No internal padding exists between members since they occupy identical byte ranges
sizeof returns the maximum member size rounded up to alignment boundary

struct example_s {
char a;      /* Offset 0, size 1 */
/* 3 bytes padding */
int b;       /* Offset 4, size 4 */
short c;     /* Offset 8, size 2 */
/* 2 bytes trailing padding */
}; /* sizeof = 12 bytes */
union example_u {
char a;      /* Offset 0, size 1 */
int b;       /* Offset 0, size 4 */
short c;     /* Offset 0, size 2 */
}; /* sizeof = 4 bytes */

The offsetof macro reflects this difference. Structure members report increasing offsets. Union members universally report offset zero, confirming identical starting addresses.

Data Access Semantics and Lifetime Rules

Access semantics define how data persists and interacts within each aggregate type.

Structures maintain concurrent member lifetimes. Writing to one field leaves all other fields untouched. Reads and writes operate independently across the entire aggregate. The compiler generates distinct memory addresses for each member, enabling parallel modification and predictable state representation.

Unions maintain exclusive member lifetimes. Writing to one member overwrites the shared memory region, invalidating all other members. Only the most recently written member contains defined data. Reading a different member invokes implementation-defined behavior based on representation compatibility. The C standard permits reading inactive members only when inspecting byte representations or when members share a common initial sequence of compatible types.

struct point p = {10, 20};
p.x = 100; /* p.y remains 20 */
union converter u;
u.integer = 0x12345678;
u.bytes[0] = 0xFF; /* Overwrites lowest byte of integer */
int val = u.integer; /* Implementation-defined: 0x123456FF on little-endian */

Union state tracking requires explicit discipline. The language provides no built-in discriminant to indicate which member is active. Developers must maintain external state variables or embed tag fields to prevent invalid reads.

Core Use Cases and Implementation Patterns

Structures dominate data aggregation scenarios requiring simultaneous field access:

Protocol headers with fixed field ordering
Configuration records and state blocks
Mathematical vectors and matrix representations
Database records and serialization payloads
Hardware register maps with independent control bits

Unions excel in variant storage and memory optimization scenarios:

Tagged unions implementing discriminated types
Memory-efficient parsing of alternative formats
Hardware register overlays with mutually exclusive modes
Type conversion and representation inspection
Event payloads with mutually exclusive data shapes

The tagged union pattern combines both types for safe variant handling:

enum TokenType { TOKEN_INT, TOKEN_FLOAT, TOKEN_STRING };
struct Token {
enum TokenType type;
union {
int int_val;
float float_val;
char *str_val;
} data;
};
void process_token(struct Token t) {
switch (t.type) {
case TOKEN_INT:    printf("%d\n", t.data.int_val); break;
case TOKEN_FLOAT:  printf("%.2f\n", t.data.float_val); break;
case TOKEN_STRING: printf("%s\n", t.data.str_val); break;
}
}

The discriminant guarantees that only the valid union member is accessed, eliminating undefined behavior and enabling static analysis validation.

Type Punning and Standard Compliance

Union-based type punning inspects the raw byte representation of data by writing through one member type and reading through another. This practice requires careful adherence to standard compliance rules.

The C standard explicitly permits union member access for representation inspection. C11 Annex J.1 classifies reading an inactive union member as implementation-defined behavior, provided the read type is compatible with the representation of the written type. Reading through unsigned char arrays is universally allowed and forms the basis for portable serialization and byte-level debugging.

Strict aliasing rules restrict pointer-based type punning but exempt union access. The compiler assumes pointers of incompatible types do not alias the same memory, enabling aggressive optimization. Unions bypass this restriction because the standard recognizes overlapping storage as intentional. Modern toolchains respect union semantics for type punning while optimizing away pointer casts.

/* Standard-compliant type punning */
union float_bytes {
float f;
unsigned char b[sizeof(float)];
};
float value = 3.14f;
union float_bytes u = { .f = value };
printf("Bytes: %02x %02x %02x %02x\n", u.b[0], u.b[1], u.b[2], u.b[3]);

C23 introduces stricter representation compatibility rules and clarifies that reading inactive members with fundamentally different representations (e.g., pointer to integer on platforms with distinct address spaces) remains implementation-defined. Developers must validate target platform behavior and avoid assumptions about byte ordering, padding, or trap representations.

Nested Combinations and Anonymous Members

C11 introduced anonymous structures and unions, enabling cleaner syntax for nested aggregates without requiring intermediate member names.

Anonymous unions embed variant fields directly into the parent scope:

struct Message {
int priority;
union {
int code;
float measurement;
char *text;
}; /* No member name required */
};
struct Message m;
m.code = 42; /* Direct access without intermediate union identifier */

Anonymous structures within unions enable shared prefix patterns:

union Node {
struct {
enum NodeType type;
struct Node *next;
} header;
struct IntNode {
enum NodeType type;
struct Node *next;
int value;
} int_node;
};

The common initial sequence rule guarantees that accessing type and next through any union member yields identical results, enabling polymorphic traversal without explicit casting.

Bit fields interact differently with each aggregate type. In structures, bit fields pack sequentially within storage units, with implementation-defined alignment and ordering. In unions, bit fields share the same underlying storage unit, enabling compact flag manipulation and hardware register mapping where multiple control bits occupy the same byte or word.

Common Pitfalls and Undefined Behavior

Assuming union members coexist causes silent data corruption. Writing one field overwrites others. Failing to track the active member leads to invalid reads and unpredictable results.

Ignoring endianness and representation differences produces platform-dependent behavior. Byte order affects how integer, float, and pointer members interpret shared memory. Code that works on little-endian x86 fails on big-endian PowerPC or embedded ARM variants.

Padding and alignment variations break direct union serialization. Different compilers may align union members differently, alter storage unit boundaries, or insert implicit padding in nested constructs. Transmitting unions directly over networks or to disk embeds platform-specific layout into external data.

Using unions for pointer aliasing without representation compatibility violates strict aliasing assumptions and triggers undefined behavior under optimization. Pointer-to-integer conversions through unions require explicit validation that both types share compatible representation on the target platform.

Forgetting to synchronize discriminants in tagged unions creates race conditions in multithreaded environments. The tag and union data must be updated atomically or protected by synchronization primitives to prevent inconsistent state reads.

Diagnostic Strategies and Compiler Behavior

Compiler warnings enforce union discipline. -Wmissing-field-initializers catches uninitialized union members. -Wtype-limits flags invalid representation conversions. -Wstrict-aliasing warns on pointer punning but exempts union access.

UndefinedBehaviorSanitizer detects invalid union access patterns when combined with -fsanitize=undefined. It flags reads of inactive members with incompatible representations and tracks tag synchronization violations in instrumented code.

Static analyzers simulate union state across control flow graphs. Clang Static Analyzer and cppcheck identify uninitialized union reads, missing discriminant checks, and unsafe type punning chains that evade manual review.

Memory inspection tools verify layout assumptions. pahole reports union size and alignment across compilation targets. GDB print commands display active member values, while x/4bx examines raw shared bytes to confirm representation interpretation.

Compiler layout dumps reveal packing and alignment decisions:

clang -Xclang -fdump-record-layouts source.c

Output confirms union member offset zero and total size alignment, enabling validation of hardware register overlays and serialization contracts.

Best Practices for Production Systems

Always embed discriminant fields with unions to track active member state explicitly
Validate representation compatibility before cross-member reads; never assume byte order independence
Prefer structures for default data aggregation; reserve unions for mutually exclusive variants
Use anonymous unions to reduce indentation depth while maintaining type safety
Document active member contracts, alignment expectations, and platform dependencies in API headers
Avoid direct union serialization; implement explicit field packing and endianness conversion
Enable strict aliasing and sanitization flags to catch invalid punning and inactive reads
Validate union size and alignment with _Static_assert across target architectures
Synchronize discriminants and union data atomically in multithreaded contexts
Test union behavior under different optimization levels and compiler versions to verify representation stability

Conclusion

Structures and unions serve complementary roles in C data aggregation. Structures allocate independent storage for concurrent field access, prioritizing predictable state representation and straightforward memory layout. Unions overlay all members in shared memory, enabling variant types, representation inspection, and memory optimization at the cost of exclusive lifetime semantics. The language permits union-based type punning and inactive member reads under implementation-defined rules, but safe usage requires explicit discriminants, representation validation, and platform-aware design. Nested anonymous members and common initial sequence rules enable flexible polymorphic patterns while maintaining type safety. Proper selection between structures and unions depends on semantic intent, memory constraints, and cross-platform serialization requirements. When applied with disciplined state tracking, explicit documentation, and comprehensive diagnostic tooling, both aggregate types form the foundation of efficient, portable, and maintainable C systems across embedded firmware, network protocols, and high-performance computational domains.

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

https://macronepal.com/understanding-the-c-srand-function
Explains how srand() initializes the pseudo-random number generator in C by setting a seed value. Using the same seed produces the same sequence, while time(NULL) gives different results each run.

2. C rand() Function Mechanics and Limitations

https://macronepal.com/c-rand-function-mechanics-and-limitations
Explains how rand() generates pseudo-random numbers between 0 and RAND_MAX, its deterministic nature, and limitations for security use cases.

3. C log() Function

https://macronepal.com/c-log-function-2
Covers natural logarithm calculation using <math.h> and its applications.

4. Mastering Date and Time in C

https://macronepal.com/mastering-date-and-time-in-c
Explains <time.h> functions like time(), clock(), difftime(), and struct tm.

5. Mastering time_t Type in C

https://macronepal.com/mastering-the-c-time_t-type-for-time-management
Explains time representation as seconds since Unix epoch and conversion functions.

6. C exp() Function

https://macronepal.com/c-exp-function-mechanics-and-implementation
Explains exponential function exp(x) and its scientific applications.

7. C log() Function (Alternate Guide)

https://macronepal.com/c-log-function
Comparison of log() and log10() with usage examples.

8. C log10() Function

https://macronepal.com/mastering-the-log10-function-in-c
Explains base-10 logarithm for engineering and scientific applications.

9. C tan() Function

https://macronepal.com/understanding-the-c-tan-function
Explains tangent function and radian-based calculations.

10. Random Numbers in C (Secure vs Predictable)

https://macronepal.com/mastering-c-random-numbers-for-secure-and-predictable-applications
Explains difference between rand() and secure randomness methods.

11. Free Online C Compiler

https://macronepal.com/free-online-c-code-compiler-2
Browser-based compiler for testing C programs instantly.

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

https://macronepal.com/c/mastering-functions-in-c-a-complete-guide/
Covers function structure, modular programming, and real-world usage.

Function Arguments in C

https://macronepal.com/c-function-arguments/
Explains how arguments are passed and used in function calls.

Function Parameters in C

https://macronepal.com/c-function-parameters/
Explains defining inputs for functions and matching them with arguments.

Function Declarations in C

https://macronepal.com/c-function-declarations-syntax-rules-and-best-practices/
Covers prototypes, syntax rules, and best practices.

Function Calls in C

https://macronepal.com/understanding-function-calls-in-c-syntax-mechanics-and-best-practices/
Explains execution flow and parameter handling during function calls.

Void Functions in C

https://macronepal.com/understanding-void-functions-in-c-syntax-patterns-and-best-practices/
Explains functions that do not return values.

Return Values in C

https://macronepal.com/c-return-values-mechanics-types-and-best-practices/
Explains different return types and how functions return results.

Pass-by-Value in C

https://macronepal.com/aws/understanding-pass-by-value-in-c-mechanics-implications-and-best-practices/
Explains how copies of variables are passed into functions.

Pass-by-Reference in C

https://macronepal.com/c/understanding-pass-by-reference-in-c-pointers-semantics-and-safe-practices/
Explains using pointers to modify original variables.

C strstr() Function

https://macronepal.com/aws/c-strstr-function/
Explains substring search inside strings in C.

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

https://macronepal.com/13757-2/
https://macronepal.com/13748-2/
https://macronepal.com/13747-2/
https://macronepal.com/13746-2/
https://macronepal.com/13745-2/
https://macronepal.com/13708-2/
https://macronepal.com/13707-2/
https://macronepal.com/13702-2/

Online Compilers