Swift Academy · Lesson

Deinitializers and Memory Lifecycle

Using deinit to clean up resources before an object is deallocated.

Lesson 4 of 412 steps

Deinitializers and Memory Lifecycle is a free Swift Academy lesson on CoddyKit. This is lesson 4 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, and your progress syncs across the web and the CoddyKit app. The Swift Academy course includes 4 lessons in total.

Welcome

Swift classes can define a `deinit` that runs just before the instance is deallocated. Understanding the full object lifecycle — init → use → deinit — is key to resource management.

What is deinit?

```swift class FileHandle { let path: String init(path: String) { self.path = path; print("Opened \(path)") } deinit { print("Closed \(path)") } } do { let f = FileHandle(path: "/tmp/log.txt") } // deinit called here when f goes out of scope ```

deinit Syntax Rules

• Classes only — structs and enums don't have `deinit` • No parameters or return value • No parentheses: `deinit { }` not `deinit() { }` • Called automatically by ARC — never call it yourself • Superclass `deinit` called automatically after subclass `deinit`

Cleanup Use Cases

Common uses for `deinit`: • Close network connections • Remove notification observers: `NotificationCenter.default.removeObserver(self)` • Invalidate timers • Close file handles or database connections

Retain Count and Lifecycle

ARC tracks how many strong references point to an object: ```swift var a: Dog? = Dog() // retain count = 1 var b = a // retain count = 2 a = nil // retain count = 1 b = nil // retain count = 0 → deinit called ```

Subclass deinit Chain

```swift class Base { deinit { print("Base deinit") } } class Child: Base { deinit { print("Child deinit") } // super.deinit called automatically after } var c: Child? = Child() c = nil // prints: Child deinit, then Base deinit ```

weak Prevents Retention

```swift class Owner { var pet: Dog? deinit { print("Owner gone") } } class Dog { weak var owner: Owner? // weak = no strong retain deinit { print("Dog gone") } } ``` When `owner` is set to nil, the `Owner` can be deallocated even though `Dog` holds a reference.

Retain Cycles Prevent deinit

```swift class A { var b: B? } class B { var a: A? } var a: A? = A() var b: B? = B() a?.b = b b?.a = a a = nil b = nil // deinit never called — retain cycle! ```

Timer Invalidation Pattern

```swift class PollingService { var timer: Timer? func start() { timer = Timer.scheduledTimer(...) } deinit { timer?.invalidate() timer = nil print("Timer stopped") } } ```

Instruments Leak Detection

If `deinit` is never called, you likely have a retain cycle. Use Xcode Instruments → Leaks template to detect objects that were allocated but never deallocated.

Quick Check

Which types can define a `deinit`?

Answer it in the interactive lesson

Recap

Key takeaways: • `deinit { }` — clean up resources before deallocation • Classes only; superclass deinit called automatically after subclass • ARC determines when deinit fires (retain count drops to 0) • Retain cycles prevent deinit — break with `weak`/`unowned` • Use Instruments Leaks to find objects whose deinit never fires Course complete! Next: enum patterns and state machines.

Free to start

Learn Swift with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 122
Lessons: 409

Start learning free View the full course

Frequently Asked Questions

Is the “Deinitializers and Memory Lifecycle” lesson free?

Yes — any 3 lessons of the Swift Academy learning path, including “Deinitializers and Memory Lifecycle”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Swift Academy course includes 4 lessons in total.

What will I learn in “Deinitializers and Memory Lifecycle”?

Using deinit to clean up resources before an object is deallocated. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 4 of 4.

How long does the “Deinitializers and Memory Lifecycle” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Class Inheritance and the super Keyword
override, final and Preventing Subclassing
Type Casting: is, as?, as! and as
Deinitializers and Memory Lifecycle

← Back to Swift Academy