Convenience Initializer

A convenience initializer is a secondary, supporting initializer for a class that provides an alternative initialization path. It must strictly delegate initialization responsibility to a designated initializer within the exact same class before it is permitted to access self or modify any properties.

In Swift, the convenience modifier is exclusive to reference types (classes). Value types (structs and enums) can perform cross-delegation without this keyword.

Syntax

A convenience initializer is declared by placing the convenience modifier immediately before the init keyword.

convenience init(parameters) {
    self.init(arguments)
    // Property modification occurs here
}

Delegation Rules

Swift enforces strict rules for class initialization to guarantee memory safety, commonly referred to as the Rule of Three:

1. Delegation Across: A convenience initializer must call another initializer from the same class using self.init. It cannot call a super.init directly.
2. Ultimate Resolution: A convenience initializer must ultimately resolve to a designated initializer. It can call another convenience initializer, but the chain of calls must end at a designated initializer.
3. Designated Delegation Up: Only designated initializers are permitted to delegate up to a superclass initializer.

Two-Phase Initialization Constraints

Convenience initializers are bound by Swift’s two-phase initialization process.

• Phase 1: The convenience initializer must delegate across (self.init) before it can assign a value to any property, including properties defined in its own class.
• Phase 2: Once the designated initializer completes the memory allocation and base initialization, control returns to the convenience initializer, which is then permitted to mutate properties or call instance methods.

Structural Example

The following code demonstrates the mechanical routing of convenience initializers without relying on a specific implementation use-case:

class Entity {
    var identifier: Int
    var status: String

    // Designated Initializer
    init(identifier: Int, status: String) {
        self.identifier = identifier
        self.status = status
    }

    // Convenience Initializer delegating to Designated Initializer
    convenience init(identifier: Int) {
        // Phase 1: Must delegate across before property mutation
        self.init(identifier: identifier, status: "Pending")
        
        // Phase 2: 'self' is now fully initialized and mutable
        self.status = "Active" 
    }

    // Convenience Initializer delegating to another Convenience Initializer
    convenience init() {
        // Resolves to the designated initializer via the chain
        self.init(identifier: 0)
    }
}

Inheritance Behavior

Convenience initializers are not directly overridden by subclasses. However, they are subject to Swift’s automatic initializer inheritance rules:

• If a subclass does not define any designated initializers, it automatically inherits all of its superclass designated and convenience initializers.
• If a subclass provides an implementation for all of its superclass’s designated initializers (either by inheriting them or overriding them), it automatically inherits all of the superclass’s convenience initializers.

Master Swift with Deep Grasping Methodology!

Learn More