Classes are reference types in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of class instance assignment

What is the output of this Swift code?

Swift

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

let person1 = Person(name: "Alice")
let person2 = person1
person2.name = "Bob"
print(person1.name)

A "Alice"

B "Bob"

C Compilation error

D "person1"

💡 Hint

Remember that classes are reference types, so both variables point to the same instance.

In Swift, classes are reference types. Assigning person1 to person2 means both refer to the same object. Changing person2.name changes the name for person1 as well.

❓ Predict Output

intermediate

Effect of modifying a class property via one reference

What will be printed by this Swift code?

Swift

class Counter {
    var count = 0
}

let c1 = Counter()
let c2 = c1
c2.count += 5
print(c1.count)

A 5

B 0

C Compilation error

D nil

💡 Hint

Both variables refer to the same instance, so changes via one affect the other.

Since Counter is a class, c1 and c2 point to the same object. Increasing c2.count changes c1.count as well.

🔧 Debug

advanced

Why does this code print 20 instead of 5?

Consider this Swift code. Why does it print 20 instead of 5?

Swift

class Number {
    var value: Int
    init(value: Int) {
        self.value = value
    }
}

func doubleValue(_ num: Number) {
    num.value *= 2
}

let n = Number(value: 5)
doubleValue(n)
doubleValue(n)
print(n.value)

A Because the function doubles the value once, but the print statement is wrong

B Because the function doubles the value twice, so 5 * 2 = 10

C Because classes are reference types, the same instance is modified twice, resulting in 20

D Because the function doubles the same instance twice, so 5 * 2 * 2 = 20

💡 Hint

Trace the value changes step by step.

The function doubleValue doubles the value property each time it is called. It is called twice, so starting from 5: first call makes it 10, second call makes it 20. The print statement prints 20.

Option C correctly explains that classes are reference types, so the same instance is modified twice.

❓ Predict Output

advanced

Output when copying class instance to a new variable

What is the output of this Swift code?

Swift

class Box {
    var content: String
    init(content: String) {
        self.content = content
    }
}

var box1 = Box(content: "Apple")
var box2 = box1
box2.content = "Orange"
print(box1.content)

A "Orange"

B Runtime error

C "box1"

D "Apple"

💡 Hint

Remember that assigning a class instance copies the reference, not the object.

Both box1 and box2 refer to the same Box instance. Changing box2.content changes box1.content as well.

❓ Predict Output

expert

Output of modifying nested class references

What will this Swift code print?

Swift

class Engine {
    var horsepower: Int
    init(horsepower: Int) {
        self.horsepower = horsepower
    }
}

class Car {
    var engine: Engine
    init(engine: Engine) {
        self.engine = engine
    }
}

let engine1 = Engine(horsepower: 150)
let car1 = Car(engine: engine1)
let car2 = car1
car2.engine.horsepower = 200
print(car1.engine.horsepower)

A 150

B nil

C Compilation error

D 200

💡 Hint

Both cars share the same engine instance because classes are reference types.

Both car1 and car2 refer to the same Car instance. The engine property is also a class instance shared by both. Changing car2.engine.horsepower changes car1.engine.horsepower.