Debugging memory leaks with Instruments in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code snippet?

Consider the following Swift code that creates a class with a closure capturing self. What will be printed when printMessage() is called?

Swift

class Printer {
    var message = "Hello"
    lazy var printClosure: () -> Void = {
        print(self.message)
    }
}

let printer = Printer()
printer.printClosure()

A Compilation error due to capturing self

B Hello

C Runtime crash due to unowned self

D nil

💡 Hint

Think about how closures capture self strongly by default in Swift.

The closure captures self strongly, so self.message is accessible and prints "Hello".

🧠 Conceptual

intermediate

Which scenario causes a retain cycle in Swift?

Choose the scenario that will cause a retain cycle leading to a memory leak.

A A struct holds a reference to a class instance.

B A class instance holds a weak reference to another class instance.

C A class instance holds a strong reference to a closure that captures self strongly.

D A closure captures a local variable by value.

💡 Hint

Retain cycles happen when two objects hold strong references to each other.

If a class instance holds a strong reference to a closure that captures self strongly, they keep each other alive, causing a retain cycle.

🔧 Debug

advanced

Identify the cause of the memory leak in this Swift code

Given the following code, what is the main cause of the memory leak?

Swift

class ViewController {
    var closure: (() -> Void)?

    func setup() {
        closure = {
            print(self)
        }
    }

    deinit {
        print("ViewController deinitialized")
    }
}

var vc: ViewController? = ViewController()
vc?.setup()
vc = nil

A The deinit method is missing causing no cleanup.

B The closure is not assigned properly causing a nil reference.

C The ViewController instance is never created.

D The closure captures self strongly causing a retain cycle.

💡 Hint

Think about how closures capture variables and how that affects object lifetime.

The closure captures self strongly, so the ViewController instance and closure keep each other alive, preventing deinitialization.

📝 Syntax

advanced

Which option correctly fixes the retain cycle in this Swift closure?

Given the code below, which option correctly fixes the retain cycle by modifying the closure?

class MyClass {
    var closure: (() -> Void)?

    func configure() {
        closure = {
            print(self)
        }
    }
}

A closure = { [unowned self] in print(self) }

B closure = { [weak self] in print(self) }

C closure = { [weak self] in print(self!) }

D closure = { print(self) }

💡 Hint

Consider how to capture self without creating a strong reference but still safely use it.

Using [unowned self] captures self without increasing retain count and assumes self will not be nil when closure runs.

🚀 Application

expert

How to detect a memory leak using Instruments in Xcode?

You suspect your Swift app has a memory leak caused by retain cycles. Which step correctly describes how to detect this leak using Instruments?

A Run the app with the Leaks instrument, perform actions, and check for persistent memory growth and leaked objects.

B Use the Time Profiler instrument to find slow functions causing leaks.

C Run the app with the Allocations instrument and ignore leaked objects.

D Use the Network instrument to monitor memory usage.

💡 Hint

Leaks instrument helps find objects that are not released properly.

The Leaks instrument detects memory that is allocated but never freed, helping identify retain cycles and leaks.