Structure vs union comparison in C++ - Trade-offs & Expert Analysis

Overview - Structure vs union comparison

What is it?

Structures and unions are ways to group different variables under one name in C++. A structure stores each member separately, so all members have their own space. A union shares the same memory space for all members, so only one member can hold a value at a time. Both help organize related data but work differently in memory.

Why it matters

Without structures and unions, programmers would have to manage many separate variables, making code messy and error-prone. Structures let you keep related data together clearly, while unions save memory when only one value is needed at a time. This helps write efficient and organized programs, especially in systems with limited memory.

Where it fits

Before learning this, you should understand basic variables and data types in C++. After this, you can learn about classes and objects, which build on structures for more complex data organization.

Mental Model

Core Idea

Structures allocate separate memory for each member, while unions share the same memory space among all members.

Think of it like...

Think of a structure like a toolbox with separate compartments for each tool, so you can store all tools at once. A union is like a single drawer where you can only keep one tool at a time, but you save space by not having multiple compartments.

Structure:  ┌─────────┬─────────┬─────────┐
           │ Member1 │ Member2 │ Member3 │
           └─────────┴─────────┴─────────┘

Union:      ┌───────────────────────┐
           │ Shared Memory for All │
           └───────────────────────┘

Build-Up - 7 Steps

1

Foundation

What is a structure in C++

Concept: Introduce the structure as a way to group variables with separate memory.

struct Point { int x; // stores x coordinate int y; // stores y coordinate }; Point p; p.x = 10; p.y = 20;

Result

You can access both x and y independently, and both keep their values separately.

Understanding that structures keep each member's data separately helps organize related information clearly.

2

Foundation

What is a union in C++

Concept: Introduce the union as a way to group variables sharing the same memory space.

union Data { int i; // integer float f; // float }; Data d; d.i = 5; // Now d.f shares the same memory as d.i

Result

Only one member can hold a meaningful value at a time because they overlap in memory.

Knowing that unions save memory by overlapping members is key to using them correctly.

3

Intermediate

Memory layout difference explained

🤔Before reading on: Do you think a structure and a union of the same members use the same amount of memory? Commit to your answer.

Concept: Explain how structures allocate memory for all members, unions allocate memory equal to the largest member.

struct Example { char c; // 1 byte int i; // 4 bytes }; union ExampleUnion { char c; // 1 byte int i; // 4 bytes }; // sizeof(Example) is usually 8 due to padding // sizeof(ExampleUnion) is 4, size of largest member

Result

Structures use more memory because they store all members separately; unions use less by sharing space.

Understanding memory layout helps optimize programs for size or speed.

4

Intermediate

Accessing members and data safety

🤔Before reading on: If you write to one union member and read from another, do you get the original value or something else? Commit to your answer.

Concept: Show how accessing different union members can lead to unexpected results, unlike structures.

union U { int i; float f; }; U u; u.i = 42; float val = u.f; // reading different member struct S { int i; float f; }; S s; s.i = 42; float val2 = s.f; // independent members

Result

Union reading different member gives unpredictable data; structure members are independent.

Knowing this prevents bugs when using unions and ensures safe data access.

5

Intermediate

Use cases for structures and unions

Concept: Explain when to use structures (grouping related data) and unions (memory optimization).

Structures are great for representing objects with multiple properties, like a 'Person' with name, age, and height. Unions are useful in low-level programming, like interpreting the same memory as different types or saving memory in embedded systems.

Result

Choosing the right type improves code clarity and efficiency.

Understanding use cases guides better design decisions in programming.

6

Advanced

Padding and alignment effects

🤔Before reading on: Do you think structures always use exactly the sum of their members' sizes? Commit to your answer.

Concept: Introduce how compilers add padding to structures for faster access, affecting size and layout.

struct Padded { char c; // 1 byte int i; // 4 bytes }; // Compiler adds 3 bytes padding after 'c' to align 'i' // sizeof(Padded) often 8 bytes, not 5 union U { char c; int i; }; // No padding in union, size is largest member size

Result

Structures may use more memory than expected due to padding; unions do not add padding between members.

Knowing padding helps understand memory usage and optimize data structures.

7

Expert

Type punning and strict aliasing rules

🤔Before reading on: Is it safe to write to one union member and read from another to reinterpret data? Commit to your answer.

Concept: Explain how unions can be used for type punning but may violate strict aliasing rules, causing undefined behavior in some compilers.

union U { int i; float f; }; U u; u.i = 0x3f800000; // bit pattern for float 1.0 float val = u.f; // type punning // This works on many compilers but may break strict aliasing rules, // leading to optimization issues or undefined behavior. // Safer alternative: use memcpy to copy bytes between types.

Result

Using unions for type punning can be risky; understanding compiler rules is essential.

Knowing language rules prevents subtle bugs and undefined behavior in advanced code.

Under the Hood

Structures allocate memory for each member sequentially, with possible padding for alignment. Each member has its own address. Unions allocate a single memory block sized to the largest member, and all members share this address. Writing to one union member overwrites the shared memory, affecting all members.

Why designed this way?

Structures were designed to group related data with clear, independent storage for each part, making access straightforward. Unions were introduced to save memory when only one of several possible data types is needed at a time, useful in low-level programming and hardware interfacing.

Structures memory layout:
┌─────────┬─────────┬─────────┐
│ Member1 │ Member2 │ Member3 │
│ (addr1) │ (addr2) │ (addr3) │
└─────────┴─────────┴─────────┘

Unions memory layout:
┌─────────────────────────┐
│ Shared memory (largest)  │
│ (same address for all)   │
└─────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does writing to one union member and reading from another always give the original value? Commit to yes or no.

Common Belief: You can safely write to one union member and read from another to convert data types.

Reality: This often causes undefined behavior due to strict aliasing rules in C++, making the result unpredictable.

Why it matters: Relying on this can cause bugs that are hard to find and may behave differently on various compilers.

Quick: Do structures and unions always use the same amount of memory if they have the same members? Commit to yes or no.

Common Belief: Structures and unions with the same members always use the same memory size.

Reality: Structures use memory equal to the sum of all members plus padding; unions use memory equal to the largest member only.

Why it matters: Misunderstanding this leads to inefficient memory use or buffer overflows.

Quick: Does a union allow storing multiple values at once like a structure? Commit to yes or no.

Common Belief: Unions can store multiple member values simultaneously like structures.

Reality: Unions can only store one member's value at a time because all members share the same memory.

Why it matters: Assuming unions hold multiple values causes data corruption and logic errors.

Quick: Is padding always added to unions like structures? Commit to yes or no.

Common Belief: Unions have padding between members just like structures.

Reality: Unions do not add padding between members because they overlap in memory; padding may only appear at the end for alignment.

Why it matters: Incorrect assumptions about padding can cause wrong size calculations and memory issues.

Expert Zone

1

Unions can be combined with structs to create tagged unions (variant types) for safer type management.

2

Compilers may optimize unions differently; understanding ABI (Application Binary Interface) details is crucial for cross-platform code.

3

Using anonymous unions inside structures allows overlaying memory without extra syntax, but can confuse code readability.

When NOT to use

Avoid unions when you need to store multiple values simultaneously or when strict type safety is required. Use structures or classes with variant types (like std::variant in C++) instead for safer and clearer code.

Production Patterns

Unions are commonly used in embedded systems to save memory and interpret hardware registers. Structures are used everywhere to model data objects. Tagged unions or variants combine both concepts for flexible and safe data handling in modern C++.

Connections

std::variant in C++

Builds-on

Understanding unions helps grasp how std::variant safely manages multiple types in one variable with type tracking.

Memory management in embedded systems

Same pattern

Knowing unions' memory sharing is essential for efficient resource use in devices with limited memory.

Human brain multitasking

Opposite pattern

Unlike unions that hold one value at a time, the brain can process multiple tasks simultaneously, highlighting different resource management strategies.

Common Pitfalls

#1 Assuming union members hold independent values simultaneously.

Wrong approach:

union U { int i; float f; } u; u.i = 10; u.f = 3.14; // expecting both values stored

Correct approach:

union U { int i; float f; } u; u.i = 10; // only one member used at a time

Root cause:

Misunderstanding that union members share the same memory location.

#2 Reading a different union member than the one last written to, expecting meaningful data.

Wrong approach:

union U { int i; float f; } u; u.i = 42; float val = u.f; // expecting val to be valid float

Correct approach:

Use memcpy or std::bit_cast (C++20) to safely reinterpret data instead of direct union member access.

Root cause:

Ignoring strict aliasing rules and undefined behavior in type punning.

#3 Ignoring padding in structures leading to wrong size assumptions.

Wrong approach:

struct S { char c; int i; }; // assuming sizeof(S) == 5 bytes

Correct approach:

Check sizeof(S) which is usually 8 bytes due to padding for alignment.

Root cause:

Not understanding compiler memory alignment and padding rules.

Key Takeaways

Structures allocate separate memory for each member, allowing all members to hold values simultaneously.

Unions share the same memory space among all members, so only one member can hold a valid value at a time.

Memory layout and padding affect the size and performance of structures and unions differently.

Using unions for type punning can cause undefined behavior; safer methods like memcpy or std::bit_cast are recommended.

Choosing between structures and unions depends on whether you need multiple values stored or memory optimization.