Why classes exist alongside structs in Swift - Visual Breakdown

Concept Flow - Why classes exist alongside structs

Start: Define Struct and Class

↓

Struct: Value Type - Copies Data

↓

Class: Reference Type - Shares Data

↓

Use Case: When to use Struct

↓

Use Case: When to use Class

↓

End: Both coexist for different needs

This flow shows why Swift has both structs and classes: structs copy data, classes share references, so each fits different needs.

Execution Sample

Swift

struct Point {
  var x: Int
  var y: Int
}

class Person {
  var name: String
  init(name: String) { self.name = name }
}

Defines a struct Point (value type) and a class Person (reference type) to show their basic difference.

Execution Table

Step	Action	Variable/Instance	Value/State	Note
1	Create Point p1	p1	x=10, y=20	Struct instance created
2	Copy p1 to p2	p2	x=10, y=20	p2 is a copy, independent
3	Change p2.x to 30	p2	x=30, y=20	Only p2 changes
4	Check p1.x	p1	x=10, y=20	p1 unchanged, shows value type
5	Create Person person1	person1	name='Alice'	Class instance created
6	Assign person1 to person2	person2	name='Alice'	person2 references same object
7	Change person2.name to 'Bob'	person2	name='Bob'	Changes reflect on both references
8	Check person1.name	person1	name='Bob'	person1 sees updated name
9	End			Execution stops after showing value vs reference behavior

💡 Execution stops after demonstrating how structs copy data and classes share references.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6	After 7	After 8	Final
p1	nil	x=10,y=20	x=10,y=20	x=10,y=20	x=10,y=20	x=10,y=20	x=10,y=20	x=10,y=20	x=10,y=20	x=10,y=20
p2	nil	nil	x=10,y=20	x=30,y=20	x=30,y=20	x=30,y=20	x=30,y=20	x=30,y=20	x=30,y=20	x=30,y=20
person1	nil	nil	nil	nil	nil	name='Alice'	name='Alice'	name='Bob'	name='Bob'	name='Bob'
person2	nil	nil	nil	nil	nil	nil	name='Alice'	name='Bob'	name='Bob'	name='Bob'

Key Moments - 3 Insights

Why does changing p2.x not affect p1.x?

Because p1 and p2 are structs (value types), copying p1 to p2 creates a separate copy. Changing p2.x only affects p2, as shown in execution_table step 3 and 4.

Why does changing person2.name also change person1.name?

Because person1 and person2 are references to the same class instance. Changing person2.name changes the shared object, so person1.name reflects that too, as seen in steps 7 and 8.

When should I use a struct instead of a class?

Use structs when you want independent copies of data (value semantics). Use classes when you want shared, mutable state (reference semantics). This is the core reason both exist.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of p1.x?

A 20

B 30

C 10

D nil

💡 Hint

Check the 'Value/State' column for p1 at step 4 in execution_table.

At which step does changing person2.name affect person1.name?

A Step 3

B Step 7

C Step 5

D Step 2

💡 Hint

Look at steps 6, 7, and 8 in execution_table for person1 and person2 name changes.

If Point was a class instead of a struct, what would happen when copying p1 to p2?

A p2 would reference the same object as p1

B p2 would be nil

C p2 would be a separate copy with independent values

D p2 would cause a compile error

💡 Hint

Recall that classes are reference types as shown by person1 and person2 behavior in execution_table.

Concept Snapshot

Swift has structs (value types) and classes (reference types).
Structs copy data when assigned or passed.
Classes share references, so changes affect all references.
Use structs for simple, independent data.
Use classes for shared, mutable state or inheritance.

Full Transcript

This visual execution shows why Swift has both classes and structs. Structs are value types, so when you copy them, you get a new independent copy. Classes are reference types, so copying just shares the same object. We create a Point struct and a Person class. Copying Point creates a new copy, so changing one does not affect the other. Copying Person shares the same object, so changing one reference changes the other. This explains why both exist: structs for independent data, classes for shared data.