Designated Initializer

A designated initializer is the primary initialization point for a class in Swift. It is responsible for fully initializing all uninitialized stored properties introduced by its own class before delegating the initialization process up the class hierarchy to its immediate superclass.

Every class must have at least one designated initializer, either explicitly defined or inherited. Unlike convenience initializers, designated initializers do not use any special modifier keywords.

init(parameters) {
    // 1. Initialize local stored properties
    // 2. Call super.init()
    // 3. Perform further configuration
}

Core Mechanics and Delegation Rules

Swift enforces strict rules for class initialization to guarantee memory safety, known as Two-Phase Initialization. Designated initializers are the structural pillars of this process and must adhere to the following compiler-enforced rules:

1. Upward Delegation: A designated initializer must call a designated initializer from its immediate superclass. It cannot call a convenience initializer from its superclass, nor can it call another designated initializer within its own class.
2. Exhaustive Local Initialization: A designated initializer must assign a value to all stored properties introduced by its specific class before it delegates up to the superclass initializer.
3. Phase 1 to Phase 2 Transition: A designated initializer cannot assign a value to an inherited property until after it has called the superclass initializer. Calling super.init() completes Phase 1 (memory allocation and base initialization) and begins Phase 2 (customization).
4. Method Resolution: A designated initializer cannot call any instance methods, read the values of any instance properties, or refer to self as a value until Phase 1 is complete.

Syntax and Execution Flow

The following example demonstrates the mechanical flow of a designated initializer adhering to Swift’s strict delegation rules:

class Vehicle {
    var wheelCount: Int

    // Base Class Designated Initializer
    init(wheelCount: Int) {
        self.wheelCount = wheelCount
    }
}

class Bicycle: Vehicle {
    var hasBasket: Bool

    // Subclass Designated Initializer
    init(hasBasket: Bool) {
        // Step 1: Initialize properties introduced by Bicycle
        self.hasBasket = hasBasket
        
        // Step 2: Delegate to the immediate superclass designated initializer
        super.init(wheelCount: 2)
        
        // Step 3: Phase 2 customization (modifying inherited properties)
        self.wheelCount = 3 // e.g., modifying to a tricycle
    }
}

The Funnel Principle

In Swift’s initialization architecture, designated initializers act as funnel points. While a class may have multiple secondary convenience initializers, those convenience initializers must delegate across to another initializer within the same class, ultimately funneling down to a single designated initializer. Only the designated initializer is permitted to delegate up to the superclass, ensuring a predictable, linear path of memory allocation and property assignment.

Master Swift with Deep Grasping Methodology!

Learn More