Deinitializers for cleanup in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using a deinitializer?

Consider this Swift class with a deinitializer. What will be printed when the instance is created and then set to nil?

Swift

class Printer {
    let message: String
    init(message: String) {
        self.message = message
        print("Init: \(message)")
    }
    deinit {
        print("Deinit: \(message)")
    }
}

var p: Printer? = Printer(message: "Hello")
p = nil

A

Init: Hello
Deinit: Hello

B Deinit: Hello

C Init: Hello

D No output

💡 Hint

Think about when the deinitializer runs in Swift.

The initializer prints when the object is created. The deinitializer runs when the object is destroyed, which happens when the variable is set to nil.

❓ Predict Output

intermediate

What happens if a class instance with a deinitializer is never set to nil?

Given this Swift code, what will be the output?

Swift

class Logger {
    deinit {
        print("Logger is being deinitialized")
    }
}

func createLogger() {
    let log = Logger()
    print("Logger created")
}

createLogger()

A No output

B

Logger is being deinitialized
Logger created

C Logger created

D

Logger created
Logger is being deinitialized

💡 Hint

Think about the lifetime of local variables in functions.

The Logger instance is created inside the function and destroyed when the function ends, triggering the deinitializer.

🔧 Debug

advanced

Why does this deinitializer not print anything?

Examine this Swift code. Why does the deinitializer message never appear?

Swift

class Resource {
    deinit {
        print("Resource cleaned up")
    }
}

var r1: Resource? = Resource()
var r2 = r1
r1 = nil
// r2 is still holding the instance

A Because r2 still holds a strong reference, so the instance is not deallocated.

B Because deinit only runs if both variables are nil at the same time.

C Because the deinitializer is not called for optional variables.

D Because the print statement is inside deinit and never executes.

💡 Hint

Think about how Swift manages memory with references.

The instance is kept alive by r2, so deinit does not run until all references are gone.

❓ Predict Output

advanced

What is the output of this Swift code with multiple instances and deinitializers?

Analyze this Swift code and select the correct output sequence.

Swift

class Item {
    let id: Int
    init(id: Int) {
        self.id = id
        print("Init \(id)")
    }
    deinit {
        print("Deinit \(id)")
    }
}

var items: [Item]? = [Item(id: 1), Item(id: 2)]
items?.append(Item(id: 3))
items = nil

A

Init 1
Init 2
Init 3
Deinit 1
Deinit 2
Deinit 3

B

Init 1
Init 2
Init 3

C

Init 1
Init 2
Init 3
Deinit 3
Deinit 2
Deinit 1

D

Init 1
Init 2
Init 3
Deinit 1
Deinit 3
Deinit 2

💡 Hint

Think about the order of initialization and deinitialization of array elements.

All three items are initialized in order. When the array is set to nil, all items are deinitialized in reverse order (last to first).

🧠 Conceptual

expert

Which statement about Swift deinitializers is true?

Choose the correct statement about deinitializers in Swift classes.

A Structs and enums can have deinitializers to clean up resources.

B Deinitializers are called automatically when the last strong reference to an instance is removed.

C You can call a deinitializer explicitly to free resources early.

D A deinitializer can be called multiple times during an object's lifetime.

💡 Hint

Recall how Swift manages memory and object lifecycle.

Deinitializers run once automatically when the last strong reference to a class instance is removed. They cannot be called manually. Structs and enums do not have deinitializers.

Practice

1. What is the main purpose of a deinitializer in Swift?

easy

A. To clean up resources before an object is destroyed

B. To initialize properties when an object is created

C. To manually call a function on an object

D. To create a new instance of a class

Solution

1. Step 1: Understand what a deinitializer does

   A deinitializer runs automatically just before an object is destroyed to clean up resources like files or network connections.

2. Step 2: Compare options with the purpose

   Only To clean up resources before an object is destroyed correctly describes this cleanup role. Options B and D describe initializers or object creation, and C is incorrect because deinitializers cannot be called manually.

3. Final Answer:

   To clean up resources before an object is destroyed -> Option A

4. Quick Check:

   Deinitializer purpose = cleanup before destruction [OK]

Hint: Deinitializer cleans up just before object is removed [OK]

Common Mistakes:

• Confusing deinitializer with initializer
• Thinking deinitializers can be called manually
• Assuming deinitializers take parameters

2. Which of the following is the correct syntax for a deinitializer in a Swift class?

easy

A. func deinitializer() { }

B. func deinit() { }

C. init deinit() { }

D. deinit { }

Solution

1. Step 1: Recall Swift deinitializer syntax

   In Swift, a deinitializer is declared with the keyword deinit without parentheses or parameters.

2. Step 2: Check each option

   deinit { } matches the correct syntax: deinit { }. Options B, C, and D incorrectly use func or parentheses.

3. Final Answer:

   deinit { } -> Option D

4. Quick Check:

   Deinitializer syntax = deinit { } [OK]

Hint: Deinitializer uses just 'deinit' keyword with braces [OK]

Common Mistakes:

• Adding parentheses after deinit
• Using 'func' keyword with deinit
• Trying to name the deinitializer function

3. What will be printed when the following Swift code runs?

class FileHandler {
    let filename: String
    init(filename: String) {
        self.filename = filename
        print("Opening file: \(filename)")
    }
    deinit {
        print("Closing file: \(filename)")
    }
}

func useFile() {
    let handler = FileHandler(filename: "data.txt")
}

useFile()

medium

A. Opening file: data.txt
Closing file: data.txt

B. Opening file: data.txt

C. Closing file: data.txt

D. No output

Solution

1. Step 1: Trace object creation and deinitialization

   When useFile() runs, it creates a FileHandler instance, printing "Opening file: data.txt". When the function ends, the local handler is destroyed, triggering the deinitializer which prints "Closing file: data.txt".

2. Step 2: Confirm output order

   First the initializer message, then the deinitializer message appear in order.

3. Final Answer:

   Opening file: data.txt Closing file: data.txt -> Option A

4. Quick Check:

   Init prints open, deinit prints close [OK]

Hint: Deinit runs after object goes out of scope [OK]

Common Mistakes:

• Assuming deinit runs immediately after init
• Thinking deinit never runs for local variables
• Ignoring print statements in deinit

4. Identify the error in this Swift class related to deinitializers:

class Connection {
    var isOpen = false
    deinit() {
        if isOpen {
            print("Closing connection")
        }
    }
}

medium

A. Deinitializer cannot access instance variables

B. Deinitializer must return a value

C. Deinitializer cannot have parentheses

D. Deinitializer must be marked with 'func'

Solution

1. Step 1: Check deinitializer syntax

   In Swift, deinitializers are declared without parentheses or parameters. The code incorrectly uses deinit() with parentheses.

2. Step 2: Verify other options

   Deinitializers do not return values, can access instance variables, and do not use the func keyword. So options A, B, and D are incorrect.

3. Final Answer:

   Deinitializer cannot have parentheses -> Option C

4. Quick Check:

   Deinit syntax = no parentheses [OK]

Hint: Deinit never uses parentheses or func keyword [OK]

Common Mistakes:

• Adding parentheses to deinit
• Expecting return values from deinit
• Using 'func' keyword with deinit

5. You have a class that manages a network connection and a file handle. How should you use a deinitializer to ensure both resources are properly closed when the object is destroyed?

class ResourceHandler {
    var connection: NetworkConnection?
    var file: FileHandle?

    init(connection: NetworkConnection?, file: FileHandle?) {
        self.connection = connection
        self.file = file
    }

    deinit {
        // What should go here?
    }
}

hard

A. Do nothing; Swift cleans up automatically

B. Call connection.close() and file.close() inside deinit if they are not nil

C. Call init() again inside deinit to reset resources

D. Set connection and file to nil inside deinit

Solution

1. Step 1: Understand resource cleanup in deinitializer

   Deinitializers are used to release resources like network connections and files. You should explicitly close these resources if they exist before the object is destroyed.

2. Step 2: Evaluate options for cleanup

   Call connection.close() and file.close() inside deinit if they are not nil correctly calls close() methods on both resources if they are not nil. Set connection and file to nil inside deinit only sets references to nil but does not close resources. Call init() again inside deinit to reset resources is invalid because calling init inside deinit is not allowed. Do nothing; Swift cleans up automatically is incorrect because Swift does not automatically close external resources.

3. Final Answer:

   Call connection.close() and file.close() inside deinit if they are not nil -> Option B

4. Quick Check:

   Deinit must close resources explicitly [OK]

Hint: Close resources explicitly in deinit before object destruction [OK]

Common Mistakes:

• Assuming setting variables to nil closes resources
• Trying to call init inside deinit
• Ignoring resource cleanup in deinit