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.

Practice

1. Which statement best describes when to use a struct instead of a class in Swift?

easy

A. Use struct when you want to share data between multiple parts of your app.

B. Use struct when you need inheritance and shared references.

C. Use struct for simple data that should be copied when assigned or passed.

D. Use struct only for UI elements like views.

Solution

1. Step 1: Understand struct behavior

   Structs are value types, meaning they are copied when assigned or passed around.

2. Step 2: Compare with class behavior

   Classes are reference types, shared by multiple references and support inheritance.

3. Final Answer:

   Use struct for simple data that should be copied when assigned or passed. -> Option C

4. Quick Check:

   Structs = copied data [OK]

Hint: Structs copy data; classes share references [OK]

Common Mistakes:

• Confusing structs with classes as reference types
• Thinking structs support inheritance
• Using structs for shared mutable state

2. Which of the following is the correct way to declare a struct in Swift?

easy

A. class Person { var name: String }

B. struct Person { var name: String }

C. struct Person: Class { var name: String }

D. class Person: struct { var name: String }

Solution

1. Step 1: Recall struct declaration syntax

   In Swift, structs are declared with the keyword struct followed by the name and braces.

2. Step 2: Check each option

   struct Person { var name: String } is correct. Using class is incorrect for structs. Structs cannot inherit from Class, and classes cannot inherit from struct.

3. Final Answer:

   struct Person { var name: String } -> Option B

4. Quick Check:

   Struct declaration = struct Name { } [OK]

Hint: Structs start with 'struct' keyword, not 'class' [OK]

Common Mistakes:

• Using 'class' keyword to declare a struct
• Trying to inherit from a class in a struct
• Mixing struct and class syntax

3. Consider this Swift code:

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

var p1 = Point(x: 1, y: 2)
var p2 = p1
p2.x = 10
print(p1.x)

What is the output?

medium

A. 1

B. 10

C. 0

D. Compilation error

Solution

1. Step 1: Understand struct copying behavior

   Assigning p1 to p2 copies the data because Point is a struct (value type).

2. Step 2: Analyze mutation effect

   Changing p2.x to 10 does not affect p1.x, which remains 1.

3. Final Answer:

   1 -> Option A

4. Quick Check:

   Struct copy means original unchanged = 1 [OK]

Hint: Structs copy on assignment; original stays same [OK]

Common Mistakes:

• Assuming p1.x changes when p2.x changes
• Confusing structs with classes (reference types)
• Expecting runtime error on mutation

4. This Swift code tries to share data between two variables:

class Counter {
  var count = 0
}

var c1 = Counter()
var c2 = c1
c2.count = 5
print(c1.count)

But the output is not as expected. What is the problem?

medium

A. Counter is a class, so c1 and c2 share the same instance

B. Counter is a class, but c2 is a copy, so changes don't reflect

C. Counter should be a struct to share data

D. Counter needs to conform to a protocol to share data

Solution

1. Step 1: Identify class reference behavior

   Classes are reference types, so c1 and c2 point to the same object.

2. Step 2: Understand shared mutation

   Changing c2.count to 5 changes the shared instance, so c1.count also becomes 5.

3. Final Answer:

   Counter is a class, so c1 and c2 share the same instance -> Option A

4. Quick Check:

   Classes share references = shared data [OK]

Hint: Classes share instances; structs copy data [OK]

Common Mistakes:

• Thinking classes copy on assignment
• Expecting structs to share data
• Believing protocols affect sharing automatically

5. You are designing a Swift app that tracks user sessions. Each session has a unique ID and mutable state shared across multiple parts of the app. Which type should you choose and why?

Options:
A) Use a struct because it copies data and avoids bugs.
B) Use a class because it allows shared mutable state with identity.
C) Use a struct with inheritance to share state.
D) Use a class but avoid mutability to keep data safe.

hard

A. Use a struct because it copies data and avoids bugs.

B. Use a class but avoid mutability to keep data safe.

C. Use a struct with inheritance to share state.

D. Use a class because it allows shared mutable state with identity.

Solution

1. Step 1: Analyze requirements for shared mutable state

   The session data must be shared and mutable across multiple parts, requiring a single shared instance.

2. Step 2: Choose between struct and class

   Structs copy data, so changes in one copy won't reflect elsewhere. Classes share references and support identity, fitting the need.

3. Step 3: Evaluate other options

   Structs do not support inheritance, so Use a struct with inheritance to share state. is invalid. Avoiding mutability in classes (Use a class but avoid mutability to keep data safe.) contradicts the requirement for mutable shared state.

4. Final Answer:

   Use a class because it allows shared mutable state with identity. -> Option D

5. Quick Check:

   Shared mutable state = class [OK]

Hint: Shared mutable data needs class, not struct [OK]

Common Mistakes:

• Choosing struct for shared mutable state
• Thinking structs support inheritance
• Avoiding mutability in classes when needed