Structure vs union comparison in C++ - Visual Side-by-Side Comparison

Concept Flow - Structure vs union comparison

Declare struct with multiple members

↓

Each member gets its own memory

↓

Assign values to members

↓

Access members independently

↓

Declare union with multiple members

↓

All members share the same memory

↓

Assign value to one member

↓

Access members (overlapping data)

↓

Observe how union stores only one value at a time

Structures allocate separate memory for each member, unions share the same memory for all members, so only one member holds a valid value at a time.

Execution Sample

C++

struct MyStruct {
  int a;
  float b;
};

union MyUnion {
  int a;
  float b;
};

MyStruct s = {10, 3.14f};
MyUnion u; u.a = 10;

This code declares a struct and a union, assigns values, and shows how memory is used differently.

Execution Table

Step	Action	Memory for struct	Memory for union	Output/Note
1	Declare struct MyStruct with int a and float b	a: uninitialized, b: uninitialized	N/A	Struct members have separate memory
2	Declare union MyUnion with int a and float b	N/A	shared memory for a and b	Union members share same memory
3	Assign s.a = 10	a: 10, b: uninitialized	N/A	Struct a set to 10
4	Assign s.b = 3.14	a: 10, b: 3.14	N/A	Struct b set independently
5	Assign u.a = 10	N/A	shared memory = 10 (int)	Union memory holds int 10
6	Access u.b	N/A	shared memory interpreted as float	Value of u.b depends on bit pattern of int 10
7	Assign u.b = 3.14	N/A	shared memory = 3.14 (float)	Union memory holds float 3.14
8	Access u.a	N/A	shared memory interpreted as int	Value of u.a depends on bit pattern of float 3.14
9	End	Struct keeps both values intact	Union only keeps last assigned value	Struct stores all members; union stores one at a time

💡 Execution ends after demonstrating memory differences and access behavior

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 7	Final
s.a	uninitialized	10	10	10	10	10
s.b	uninitialized	uninitialized	3.14	3.14	3.14	3.14
u.a	uninitialized	uninitialized	uninitialized	10	bit pattern of 3.14	bit pattern of 3.14
u.b	uninitialized	uninitialized	uninitialized	bit pattern of 10	3.14	3.14

Key Moments - 3 Insights

Why does changing one union member affect the others?

Because all union members share the same memory, assigning to one overwrites the data for all others, as shown in steps 5 to 8 in the execution_table.

Can a struct hold multiple values at the same time?

Yes, each struct member has its own memory space, so all members keep their values independently, as seen in steps 3 and 4.

Why does accessing a different union member after assignment give strange values?

Because the bits are interpreted differently depending on the member type, so reading u.b after assigning u.a shows the float interpretation of the int bits (step 6).

Visual Quiz - 3 Questions

Look at the execution_table at step 5. What value is stored in the union's shared memory?

A Uninitialized

B Float 3.14

C Integer 10

D Both 10 and 3.14

💡 Hint

Check the 'Memory for union' column at step 5 in execution_table

At which step does the struct have both members assigned values?

A Step 4

B Step 3

C Step 5

D Step 7

💡 Hint

Look at 'Memory for struct' column in execution_table for when both a and b have values

If you assign a value to u.b after u.a, what happens to u.a's value?

A It stays the same

B It changes to reflect the bit pattern of u.b

C It becomes uninitialized

D It doubles

💡 Hint

Refer to steps 7 and 8 in execution_table and variable_tracker for u.a and u.b

Concept Snapshot

Structure vs Union in C++:
- struct: each member has its own memory
- union: all members share the same memory
- struct stores all member values simultaneously
- union stores only one member value at a time
- Accessing different union members interprets same bits differently

Full Transcript

This visual execution compares structures and unions in C++. Structures allocate separate memory for each member, so all members keep their values independently. Unions share the same memory for all members, so only one member holds a valid value at a time. Assigning to one union member overwrites the shared memory, affecting all members. Accessing a different union member after assignment shows the bits interpreted as that member's type, which can look like strange values. The execution table traces each step, showing how struct members keep their values separately, while union members overlap in memory. The variable tracker shows the values changing after each assignment. Key moments clarify why union members affect each other and why structs keep all values. The quiz tests understanding of memory usage and value changes in both types.