Comparing structs vs classes decision in Swift - Visual Side-by-Side Comparison

Concept Flow - Comparing structs vs classes decision

Start: Need to model data

↓

Decide: Value or Reference?

↓

Use Struct

↓

Copy on [Shared reference

↓

changes affect all

↓

Immutable [Mutable by default

↓

End Decision

This flow shows how to decide between struct and class by choosing value or reference type, considering copying behavior, mutability, and use cases.

Execution Sample

Swift

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

class Circle {
  var center: Point
  var radius: Int
  init(center: Point, radius: Int) {
    self.center = center
    self.radius = radius
  }
}

Defines a struct Point as a value type and a class Circle as a reference type holding a Point.

Execution Table

Step	Action	Variable/Instance	Value/State	Notes
1	Create Point p1	p1	Point(x: 1, y: 2)	Struct instance created
2	Assign p2 = p1	p2	Point(x: 1, y: 2)	Copy of p1, independent
3	Modify p2.x = 3	p2	Point(x: 3, y: 2)	p2 changed, p1 unchanged
4	Create Circle c1	c1	Circle(center: Point(x: 1, y: 2), radius: 5)	Class instance created
5	Assign c2 = c1	c2	Circle(center: Point(x: 1, y: 2), radius: 5)	Reference copy, same instance
6	Modify c2.radius = 10	c2	Circle(center: Point(x: 1, y: 2), radius: 10)	Change affects c1 too
7	Check c1.radius	c1.radius	10	Shows shared reference
8	End			Demonstrates struct copy vs class reference

💡 Execution stops after showing difference in copying behavior between struct and class.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	After Step 6	Final
p1	undefined	Point(x:1,y:2)	Point(x:1,y:2)	Point(x:1,y:2)	Point(x:1,y:2)	Point(x:1,y:2)
p2	undefined	Point(x:1,y:2)	Point(x:3,y:2)	Point(x:3,y:2)	Point(x:3,y:2)	Point(x:3,y:2)
c1	undefined	undefined	undefined	Circle(center:Point(x:1,y:2),radius:5)	Circle(center:Point(x:1,y:2),radius:10)	Circle(center:Point(x:1,y:2),radius:10)
c2	undefined	undefined	undefined	Circle(center:Point(x:1,y:2),radius:5)	Circle(center:Point(x:1,y:2),radius:10)	Circle(center:Point(x:1,y:2),radius:10)

Key Moments - 3 Insights

Why does changing p2 not affect p1, but changing c2 affects c1?

Because p1 and p2 are structs (value types), assigning p2 = p1 copies the data, so they are independent (see steps 2 and 3). c1 and c2 are classes (reference types), so c2 = c1 copies the reference, both point to the same object (see steps 5 and 6).

What does it mean that structs are 'immutable by default'?

Structs are value types and if declared with 'let', their properties cannot change. In this example, we used 'var' so properties can change, but copying still creates independent copies (see step 3).

When should I choose a class over a struct?

Choose a class when you need shared mutable state or inheritance. Classes allow multiple references to the same object, so changes affect all references (see steps 5-7).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of p1 after step 3?

A Point(x: 3, y: 2)

B Point(x: 1, y: 3)

C Point(x: 1, y: 2)

D Undefined

💡 Hint

Check the 'Value/State' column for p1 at step 3 in the execution table.

At which step does changing one variable affect another due to shared reference?

A Step 3

B Step 6

C Step 2

D Step 1

💡 Hint

Look at steps where c1 and c2 share the same instance in the execution table.

If p2 was a class instead of a struct, what would happen when modifying p2.x at step 3?

A p1.x would also change

B p1.x would stay the same

C Compilation error

D p2.x would revert to original

💡 Hint

Recall that classes are reference types and changes affect all references (see steps 5-7).

Concept Snapshot

Structs are value types: copied on assignment, independent, good for simple data.
Classes are reference types: shared references, changes affect all, support inheritance.
Use structs for safety and simplicity; use classes for shared mutable state or polymorphism.
Structs are immutable if declared with let; classes are mutable by default.
Decide based on whether you want copies or shared objects.

Full Transcript

This visual execution compares structs and classes in Swift. Structs are value types, so when you assign one struct to another, it copies the data. Changing the copy does not affect the original. Classes are reference types, so assigning one class instance to another copies the reference, not the data. Changing one reference affects the other because they point to the same object. The example shows creating a Point struct and copying it, then modifying the copy without changing the original. It also shows creating a Circle class, copying the reference, and modifying one reference changes the shared object. This helps decide when to use structs or classes based on copying behavior, mutability, and use cases.