ARC overview for memory management in Swift - Step-by-Step Execution

Concept Flow - ARC overview for memory management

Create Object

↓

Increase Reference Count

↓

Use Object

↓

Decrease Reference Count

↓

Reference Count == 0?

No→Keep Object Alive

Yes↓

Deallocate Object

This flow shows how ARC tracks how many references point to an object. When no references remain, ARC frees the object.

Execution Sample

Swift

class Person {
  var name: String
  init(name: String) { self.name = name }
  deinit { print("Person deallocated") }
}

var p1: Person? = Person(name: "Anna")
p1 = nil

This code creates a Person object, assigns it to p1, then sets p1 to nil, triggering ARC to deallocate the object.

Execution Table

Step	Action	Reference Count	Object State	Output
1	Create Person("Anna") and assign to p1	1	Object alive
2	Set p1 = nil (remove reference)	0	Object deallocated	Person deallocated
3	End	-	-	No references remain, object freed

💡 Reference count reached zero after p1 set to nil, so ARC deallocates the object.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
p1	nil	Person instance	nil	nil
Reference Count	0	1	0	0

Key Moments - 3 Insights

Why does setting p1 to nil cause the object to be deallocated?

Because p1 was the only reference to the object, setting it to nil reduces the reference count to zero, triggering ARC to free the object (see execution_table step 2).

What happens if multiple variables reference the same object?

ARC increases the reference count for each variable. The object is only deallocated when all references are removed, meaning the count reaches zero.

Why do we see 'Person deallocated' printed?

The deinit method runs when ARC frees the object, showing that the object is cleaned up properly (see execution_table step 2 output).

Visual Quiz - 3 Questions

Look at the execution table, what is the reference count after creating the Person object?

A 0

B 1

C 2

D nil

💡 Hint

Check execution_table row 1 under 'Reference Count'

At which step does ARC deallocate the object?

A Step 1

B Step 3

C Step 2

D Never

💡 Hint

See execution_table row 2 where reference count becomes zero and object is deallocated

If another variable p2 also referenced the Person object, what would happen when p1 is set to nil?

A Reference count decreases but object stays alive

B Reference count increases

C Object is deallocated immediately

D Program crashes

💡 Hint

Recall that ARC deallocates only when reference count reaches zero; see key_moments about multiple references

Concept Snapshot

ARC (Automatic Reference Counting) tracks how many references point to an object.
When references increase, count goes up; when references are removed, count goes down.
If count reaches zero, ARC frees the object automatically.
Use optional variables to hold references; setting them to nil removes references.
Deinit runs when object is deallocated, useful for cleanup.

Full Transcript

This visual execution shows how ARC manages memory in Swift. First, creating a Person object sets its reference count to 1 because p1 points to it. When p1 is set to nil, the reference count drops to zero. ARC then deallocates the object, running the deinit method which prints 'Person deallocated'. Variables hold references; ARC counts these references to decide when to free memory. If multiple variables reference the same object, ARC waits until all are nil before deallocating. This automatic process helps prevent memory leaks and crashes by cleaning up unused objects safely.

Practice

1. What does ARC stand for in Swift's memory management?

easy

A. Active Reference Control

B. Automatic Resource Control

C. Asynchronous Runtime Code

D. Automatic Reference Counting

Solution

1. Step 1: Understand the acronym ARC

   ARC in Swift stands for Automatic Reference Counting, which manages memory automatically.

2. Step 2: Eliminate incorrect options

   Other options do not match the correct term used in Swift memory management.

3. Final Answer:

   Automatic Reference Counting -> Option D

4. Quick Check:

   ARC = Automatic Reference Counting [OK]

Hint: Remember ARC counts references automatically [OK]

Common Mistakes:

• Confusing ARC with manual memory management
• Thinking ARC stands for resource control
• Mixing ARC with asynchronous code concepts

2. Which of the following is the correct way to declare a class in Swift that ARC will manage?

easy

A. struct Person {}

B. class Person {}

C. func Person() {}

D. var Person = {}

Solution

1. Step 1: Identify ARC-managed types

   ARC manages memory for class instances, so classes are declared with class.

2. Step 2: Check syntax correctness

   class Person {} is the correct syntax for a class in Swift.

3. Final Answer:

   class Person {} -> Option B

4. Quick Check:

   Class declaration = class Person {} [OK]

Hint: ARC manages classes, not structs or functions [OK]

Common Mistakes:

• Using struct instead of class for ARC examples
• Trying to declare a class with func or var
• Confusing function and class syntax

3. Consider the following Swift code:

class Dog {}
var dog1: Dog? = Dog()
var dog2 = dog1
 dog1 = nil
print(dog2 == nil)

What will be printed?

medium

A. true

B. Compile error

C. false

D. nil

Solution

1. Step 1: Analyze reference assignments

   dog1 is assigned a Dog instance, dog2 copies the reference from dog1, so both point to the same object.

2. Step 2: Effect of setting dog1 to nil

   Setting dog1 to nil removes one reference, but dog2 still holds the reference, so the object remains alive.

3. Step 3: Evaluate print statement

   dog2 is not nil, so dog2 == nil is false, so it prints false.

4. Final Answer:

   false -> Option C

5. Quick Check:

   dog2 still references object = false [OK]

Hint: Setting one reference nil doesn't free object if others exist [OK]

Common Mistakes:

• Assuming dog2 becomes nil when dog1 is nil
• Confusing reference assignment with copying object
• Expecting a compile error due to optional usage

4. What is the problem with this Swift code snippet related to ARC?

class Person {
  var friend: Person?
}

var alice: Person? = Person()
alice?.friend = alice
alice = nil

medium

A. Memory leak due to strong reference cycle

B. Compile error because of optional chaining

C. No problem, memory is freed correctly

D. Runtime crash due to nil assignment

Solution

1. Step 1: Identify reference cycle

   alice references a Person instance, and that instance's friend property points back to alice, creating a strong cycle.

2. Step 2: Effect on ARC

   Because both references are strong, ARC cannot free the Person instance even after alice is set to nil, causing a memory leak.

3. Final Answer:

   Memory leak due to strong reference cycle -> Option A

4. Quick Check:

   Strong cycle prevents deallocation = memory leak [OK]

Hint: Strong references pointing to each other cause leaks [OK]

Common Mistakes:

• Thinking optional chaining causes compile error
• Assuming ARC frees memory despite cycles
• Believing nil assignment crashes program

5. You want to avoid a strong reference cycle between two classes Owner and Pet. Which is the best way to declare the reference from Pet to Owner to prevent memory leaks?

hard

A. Declare the reference as weak var owner: Owner?

B. Declare the reference as var owner: Owner

C. Declare the reference as unowned var owner: Owner?

D. Declare the reference as let owner: Owner

Solution

1. Step 1: Understand strong vs weak references

   Strong references increase ARC count and can cause cycles; weak references do not increase ARC count.

2. Step 2: Choose weak reference to break cycle

   Declaring owner as weak var owner: Owner? allows ARC to free objects properly by not increasing reference count.

3. Final Answer:

   Declare the reference as weak var owner: Owner? -> Option A

4. Quick Check:

   Use weak to avoid strong reference cycles [OK]

Hint: Use weak references to break cycles safely [OK]

Common Mistakes:

• Using unowned incorrectly causing crashes
• Using strong references causing memory leaks
• Forgetting to make weak references optional