ARC overview for memory management in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this ARC example?

Consider this Swift code using ARC. What will be printed?

Swift

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

var reference1: Person? = Person(name: "Alice")
var reference2 = reference1
reference1 = nil
print("Reference1 is nil")
reference2 = nil
print("Reference2 is nil")

A

Alice is initialized
Reference1 is nil
Alice is being deinitialized
Reference2 is nil

B

Alice is initialized
Alice is being deinitialized
Reference1 is nil
Reference2 is nil

C

Reference1 is nil
Reference2 is nil
Alice is initialized
Alice is being deinitialized

D

Alice is initialized
Reference1 is nil
Reference2 is nil
Alice is being deinitialized

💡 Hint

Think about when the last strong reference to the object is removed.

The Person instance is created and initialized first. Then reference1 is set to nil, but reference2 still holds the object, so it is not deinitialized yet. When reference2 is set to nil, no strong references remain, so deinit is called.

🧠 Conceptual

intermediate

Which statement about ARC is true?

Choose the correct statement about Automatic Reference Counting (ARC) in Swift.

A ARC increases the reference count when a weak reference is created.

B ARC requires manual calls to free memory after using an object.

C ARC only works with value types like structs and enums.

D ARC automatically frees memory when there are no more strong references to an object.

💡 Hint

Think about how ARC manages memory automatically.

ARC automatically tracks and frees memory when no strong references to an object remain. Weak references do not increase the reference count. ARC does not require manual memory management and works with class instances (reference types), not value types.

❓ Predict Output

advanced

What error occurs with this ARC cycle?

What happens when this Swift code runs?

Swift

class Node {
    var next: Node?
    deinit {
        print("Node is being deinitialized")
    }
}

var node1: Node? = Node()
var node2: Node? = Node()
node1!.next = node2
node2!.next = node1
node1 = nil
node2 = nil

A Compile-time error: Cannot assign to property

B

Node is being deinitialized
Node is being deinitialized

C No output, memory leak occurs due to strong reference cycle.

D Runtime error: Stack overflow

💡 Hint

Think about what happens when two objects strongly reference each other.

The two Node instances strongly reference each other, creating a cycle. Even after setting node1 and node2 to nil, the objects remain in memory because their reference counts never reach zero. No deinit is called, causing a memory leak.

❓ Predict Output

advanced

What is printed with weak references?

What will this Swift code print?

Swift

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) initialized")
    }
    deinit {
        print("\(name) deinitialized")
    }
}

class Apartment {
    weak var tenant: Person?
}

var person: Person? = Person(name: "Bob")
var apartment: Apartment? = Apartment()
apartment!.tenant = person
person = nil
print("Person is nil")

A

Bob initialized
Person is nil

B

Bob initialized
Bob deinitialized
Person is nil

C

Person is nil
Bob deinitialized

D

Bob initialized
Bob deinitialized

💡 Hint

Weak references do not keep the object alive.

The Person instance is created and assigned to apartment's weak tenant property. When person is set to nil, no strong references remain, so deinit is called. The weak reference does not keep the object alive.

🧠 Conceptual

expert

Why use unowned references in ARC?

Which is the best reason to use an unowned reference instead of a weak reference in Swift ARC?

A When the referenced object will always have a longer lifetime and never be nil during the reference's lifetime.

B When you want the reference to automatically become nil when the object is deallocated.

C When you want to create a strong reference cycle intentionally.

D When the referenced object is a value type like a struct.

💡 Hint

Think about the difference between weak and unowned references regarding nil values.

Unowned references are used when the referenced object is expected to always exist during the lifetime of the reference, so it is not optional and does not become nil. Weak references are optional and become nil automatically. Using unowned incorrectly can cause runtime crashes.