Weak references to break cycles in Swift - Mini Project: Build & Apply

Weak references to break cycles

📖 Scenario: Imagine you are building a simple app to manage a library system. You have Book and Author classes. Each book has an author, and each author has a list of books they wrote. This creates a cycle in memory references.To prevent memory leaks, you need to use weak references in Swift.

🎯 Goal: You will create Book and Author classes with properties referencing each other. Then, you will use a weak reference to break the cycle and print the author and book details.

📋 What You'll Learn

Create a class Author with a name property and a books array property.

Create a class Book with a title property and an author property.

Make the author property in Book a weak reference to avoid a strong reference cycle.

Create instances of Author and Book and link them.

Print the author name and the titles of their books.

💡 Why This Matters

🌍 Real World

In real apps, especially with user interfaces and data models, objects often reference each other. Using weak references prevents memory leaks and keeps the app efficient.

💼 Career

Understanding how to manage memory with weak references is essential for Swift developers to write safe and performant code, especially in iOS app development.

1

Create the Author and Book classes

Create a class called Author with a name property of type String and a books property which is an array of Book. Also create a class called Book with a title property of type String and an author property of type Author? (optional).

Swift

# Your code here

Hint

Define two classes with the properties exactly as described. Use optional type for author in Book.

2

Make the author property weak to avoid cycles

Change the author property in the Book class to be a weak reference of type Author?.

Swift

class Author {
    let name: String
    var books: [Book] = []
    
    init(name: String) {
        self.name = name
    }
}

class Book {
    let title: String
    // Make author a weak reference
    var author: Author?
    
    init(title: String, author: Author?) {
        self.title = title
        self.author = author
    }
}

Hint

Use the weak keyword before the author property declaration.

3

Create instances and link them

Create an instance of Author named author with the name "Jane Austen". Create two Book instances named book1 and book2 with titles "Pride and Prejudice" and "Sense and Sensibility" respectively, and set their author property to the author instance. Add both books to the author.books array.

Swift

class Author {
    let name: String
    var books: [Book] = []
    
    init(name: String) {
        self.name = name
    }
}

class Book {
    let title: String
    weak var author: Author?
    
    init(title: String, author: Author?) {
        self.title = title
        self.author = author
    }
}

// Create author and books, link them

Hint

Create the instances exactly with the given names and values. Append the books to the author's books array.

4

Print author and book details

Write code to print the author's name and then print the titles of all books in the author.books array, each on a new line.

Swift

class Author {
    let name: String
    var books: [Book] = []
    
    init(name: String) {
        self.name = name
    }
}

class Book {
    let title: String
    weak var author: Author?
    
    init(title: String, author: Author?) {
        self.title = title
        self.author = author
    }
}

let author = Author(name: "Jane Austen")
let book1 = Book(title: "Pride and Prejudice", author: author)
let book2 = Book(title: "Sense and Sensibility", author: author)
author.books.append(book1)
author.books.append(book2)

// Print author name and book titles

Hint

Use print to show the author's name and then loop through author.books to print each book's title.

Practice

1. What is the main purpose of using weak references in Swift?

easy

A. To increase the performance of the program by caching values

B. To prevent strong reference cycles and allow objects to be deallocated

C. To make variables constant and unchangeable

D. To create multiple copies of an object automatically

Solution

1. Step 1: Understand what strong reference cycles are

   Strong reference cycles happen when two objects hold strong references to each other, preventing deallocation.

2. Step 2: Role of weak references

   Weak references do not increase the reference count, so they help break these cycles and allow memory to be freed.

3. Final Answer:

   To prevent strong reference cycles and allow objects to be deallocated -> Option B

4. Quick Check:

   Weak references prevent cycles = C [OK]

Hint: Weak references avoid memory cycles by not owning objects [OK]

Common Mistakes:

• Thinking weak makes variables constant
• Confusing weak with performance optimization
• Assuming weak creates copies

2. Which of the following is the correct syntax to declare a weak reference to an instance of class Person in Swift?

easy

A. weak var friend: Person?

B. weak let friend: Person?

C. weak var friend: Person

D. var weak friend: Person?

Solution

1. Step 1: Understand weak reference syntax

   Weak references must be declared with weak var and must be optional because the referenced object can be nil.

2. Step 2: Check each option

   weak var friend: Person? uses weak var friend: Person?, which is correct syntax.

3. Final Answer:

   weak var friend: Person? -> Option A

4. Quick Check:

   Weak references use 'weak var' and optional type = A [OK]

Hint: Weak references are always optional vars [OK]

Common Mistakes:

• Using 'let' with weak
• Not making the type optional
• Placing 'weak' after 'var'

3. Consider the following Swift code snippet:

class Owner {
    var pet: Pet?
}

class Pet {
    weak var owner: Owner?
}

let owner = Owner()
let pet = Pet()
owner.pet = pet
pet.owner = owner

print(owner.pet!.owner! === owner)

What is the output of this code?

medium

A. nil

B. false

C. true

D. Compilation error

Solution

1. Step 1: Understand the references

   The Owner has a strong reference to Pet, and Pet has a weak reference back to Owner.

2. Step 2: Evaluate the print statement

   The expression owner.pet!.owner! === owner checks if the pet's owner is the same instance as owner. Since pet.owner weakly references owner, this is true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   Weak reference points back correctly = true [OK]

Hint: Weak references still point to original object if alive [OK]

Common Mistakes:

• Thinking weak reference becomes nil immediately
• Confusing identity check with equality
• Expecting compilation error due to weak

4. Given the following code, why does it cause a strong reference cycle?

class A {
    var b: B?
}

class B {
    var a: A?
}

let a = A()
let b = B()
a.b = b
b.a = a

How can you fix this cycle?

medium

A. Change a in class B to a weak reference

B. Change b in class A to a weak reference

C. Make both references strong

D. Use unowned for both references

Solution

1. Step 1: Identify the cycle

   Class A holds a strong reference to B, and B holds a strong reference back to A, causing a cycle.

2. Step 2: Break the cycle with weak reference

   Changing the reference from B to A to weak var a: A? breaks the cycle because B no longer strongly owns A.

3. Final Answer:

   Change a in class B to a weak reference -> Option A

4. Quick Check:

   Break cycle by making one side weak = D [OK]

Hint: Make one side weak to break cycles [OK]

Common Mistakes:

• Making both references weak (loses ownership)
• Making the wrong reference weak
• Using unowned incorrectly causing crashes

5. You have two classes, Teacher and Student, where each Teacher has many Students and each Student has one Teacher. How should you declare the references to avoid strong reference cycles?

hard

A. Teacher holds weak references to Students; Student holds a strong reference to Teacher

B. Both hold weak references

C. Both hold strong references

D. Teacher holds strong references to Students; Student holds a weak reference to Teacher

Solution

1. Step 1: Analyze ownership

   A Teacher owns many Students, so it should hold strong references to them.

2. Step 2: Avoid cycle by weak reference

   Each Student should hold a weak reference back to its Teacher to avoid a strong cycle.

3. Final Answer:

   Teacher holds strong references to Students; Student holds a weak reference to Teacher -> Option D

4. Quick Check:

   Owner strong, back weak = B [OK]

Hint: Owner holds strong, back reference is weak [OK]

Common Mistakes:

• Making owner reference weak
• Making both references strong causing cycles
• Making both references weak losing ownership