𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗦𝘄𝗶𝗳𝘁 𝗠𝗲𝗺𝗼𝗿𝘆 𝗠𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁: 𝗦𝘁𝗿𝗼𝗻𝗴, 𝗪𝗲𝗮𝗸 & 𝗨𝗻𝗼𝘄𝗻𝗲𝗱 𝗥𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲𝘀

Understanding how references work in Swift is key to preventing retain cycles and memory leaks. Below are simple, real-world examples for each reference type — complete with diagrams, code samples, and a comparison table.

1. 𝗦𝘁𝗿𝗼𝗻𝗴 𝗥𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲 (Default)

Real-World Example:
Imagine a Book in your personal library. The library holds a strong reference to the Book, ensuring it stays in memory until you remove it.

Diagram:

myBook (strong) ---> Book instance

Code Example:

class Book {
    let title: String
    init(title: String) {
        self.title = title
        print("Book '\(title)' is created")
    }
    deinit {
        print("Book '\(title)' is deallocated")
    }
}

var myBook: Book? = Book(title: "Swift Programming")
// 'myBook' holds a strong reference to the Book.
myBook = nil  // The Book is deallocated.

Explanation:
A strong reference increases the reference count. As long as the variable exists, the object remains in memory.

2. 𝗪𝗲𝗮𝗸 𝗥𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲

Real-World Example:
Consider a Parent-Child relationship. A parent holds a strong reference to the child, while the child’s reference back to the parent is weak — preventing a retain cycle.

Get Bala Baskar Bollisetty’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Diagram:

Parent --(strong)--> Child  
Child --(weak)--> Parent

Code Example:

class Parent {
    var child: Child?
    init() { print("Parent created") }
    deinit { print("Parent deallocated") }
}

class Child {
    // The child's reference to its parent is weak.
    weak var parent: Parent?
    init() { print("Child created") }
    deinit { print("Child deallocated") }
}

var mom: Parent? = Parent()
var kid: Child? = Child()

mom?.child = kid       // Strong reference from Parent to Child.
kid?.parent = mom      // Weak reference from Child to Parent.

// Break both references.
mom = nil
kid = nil

Explanation:
A weak reference does not increase the reference count and automatically becomes nil when the object is deallocated, effectively breaking the cycle.

3. 𝗨𝗻𝗼𝘄𝗻𝗲𝗱 𝗥𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲

Real-World Example:
Think of a Car and its Engine. A car always has an engine. The car holds a strong reference to its engine, while the engine uses an unowned reference back to the car — assuming the car will always exist during the engine’s lifetime.

Diagram:

Car --(strong)--> Engine  
Engine --(unowned)--> Car

Code Example:

class Car {
    let model: String
    var engine: Engine?
    
    init(model: String) {
        self.model = model
        print("Car \(model) is created")
    }
    
    deinit {
        print("Car \(model) is deallocated")
    }
}

class Engine {
    let serialNumber: String
    // Unowned because the engine always belongs to a Car.
    unowned let car: Car
    
    init(serialNumber: String, car: Car) {
        self.serialNumber = serialNumber
        self.car = car
        print("Engine \(serialNumber) is created for \(car.model)")
    }
    
    deinit {
        print("Engine \(serialNumber) is deallocated")
    }
}

// Example usage:
var myCar: Car? = Car(model: "Toyota Camry")
myCar?.engine = Engine(serialNumber: "ENG12345", car: myCar!)
// When 'myCar' is set to nil, both Car and Engine are deallocated.
myCar = nil

Explanation:
An unowned reference does not increase the reference count and cannot be nil. It’s used when you’re certain the referenced object will outlive the reference.

𝗞𝗲𝘆 𝗗𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝗰𝗲𝘀 𝗕𝗲𝘁𝘄𝗲𝗲𝗻 𝗦𝘁𝗿𝗼𝗻𝗴, 𝗪𝗲𝗮𝗸 & 𝗨𝗻𝗼𝘄𝗻𝗲𝗱 𝗥𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲𝘀

+--------------------+---------------------------+---------------------+--------------------------------------------------+
| Reference Type     | Increases Reference Count | Optional?           | When to Use                                      |
+--------------------+---------------------------+---------------------+--------------------------------------------------+
| Strong             | Yes                       | N/A (default type)  | When you "own" the object to keep it alive       |
| Weak               | No                        | Yes (auto nil)      | When the object might be deallocated             |
| Unowned            | No                        | No                  | When the object is guaranteed to exist           |
|                    |                           |                     | (e.g., a Car's engine always exists with a Car)  |
+--------------------+---------------------------+---------------------+--------------------------------------------------+

𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀

• Strong Reference: Keeps the object alive as long as the reference exists.
• Weak Reference: Prevents retain cycles by not increasing the reference count; automatically becomes nil when the object is deallocated.
• Unowned Reference: Assumes the object will always be available; ideal for relationships where the referenced object must persist.

Using the correct reference type helps manage memory efficiently and ensures your Swift applications run smoothly.

#Swift #iOSDevelopment #MemoryManagement #RetainCycles #CodingTips