Чому Swift-ініціалізатори не можуть викликати зручні ініціалізатори на своєму суперкласі?

Розглянемо два класи:

class A {
    var x: Int

    init(x: Int) {
        self.x = x
    }

    convenience init() {
        self.init(x: 0)
    }
}

class B: A {
    init() {
        super.init() // Error: Must call a designated initializer of the superclass 'A'
    }
}

Я не розумію, чому це заборонено. В кінцевому рахунку, призначений ініціалізатор кожного класу викликається з будь-якими значеннями , які вони потрібні, так чому я повинен повторити себе в B«S init, вказавши значення за замовчуванням для xзнову, коли зручність initв Aробитиме тільки штраф?

Це Правило 1 правил "Прив'язка ініціалізаторів", як зазначено в Посібнику з програмування Swift, яке говорить:

Правило 1: Призначені ініціалізатори повинні викликати призначений ініціалізатор зі свого безпосереднього суперкласу.

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html

Акцент мій. Призначені ініціалізатори не можуть викликати зручні ініціалізатори.

Існує схема, яка поєднується з правилами, щоб продемонструвати, які дозволені "напрямки" ініціалізатора:

Поміркуйте

class A
{
    var a: Int
    var b: Int

    init (a: Int, b: Int) {
        print("Entering A.init(a,b)")
        self.a = a; self.b = b
    }

    convenience init(a: Int) {
        print("Entering A.init(a)")
        self.init(a: a, b: 0)
    }

    convenience init() {
        print("Entering A.init()")
        self.init(a:0)
    }
}


class B : A
{
    var c: Int

    override init(a: Int, b: Int)
    {
        print("Entering B.init(a,b)")
        self.c = 0; super.init(a: a, b: b)
    }
}

var b = B()

Оскільки всі призначені ініціалізатори класу A замінені, клас B успадковує всі зручні ініціалізатори A. Таким чином, виконання цього виведе

Entering A.init()
Entering A.init(a:)
Entering B.init(a:,b:)
Entering A.init(a:,b:)

Тепер, якщо призначеному ініціалізатору B.init (a: b :) буде дозволено викликати ініціалізатор зручності базового класу A.init (a :), це призведе до рекурсивного виклику B.init (a:, b: ).

Це тому, що у вас може вийти нескінченна рекурсія. Розглянемо:

class SuperClass {
    init() {
    }

    convenience init(value: Int) {
        // calls init() of the current class
        // so init() for SubClass if the instance
        // is a SubClass
        self.init()
    }
}

class SubClass : SuperClass {
    override init() {
        super.init(value: 10)
    }
}

і подивіться на:

let a = SubClass()

який буде дзвонити, SubClass.init()який буде дзвонити, SuperClass.init(value:)який буде дзвонитиSubClass.init() .

Призначені / зручні правила ініціювання розроблені таким чином, щоб ініціалізація класу завжди була правильною.

Я знайшов для цього роботу. Це не надзвичайно красиво, але вирішує проблему невідомості значень суперкласу або бажання встановити значення за замовчуванням.

Все, що вам потрібно зробити, це створити екземпляр суперкласу, використовуючи зручність init, прямо в initпідкласі. Потім ви викликаєте призначеного initсупер, використовуючи щойно створений екземпляр.

class A {
    var x: Int

    init(x: Int) {
        self.x = x
    }

    convenience init() {
        self.init(x: 0)
    }
}

class B: A {
    init() {
        // calls A's convenience init, gets instance of A with default x value
        let intermediate = A() 

        super.init(x: intermediate.x) 
    }
}

Розгляньте можливість вилучення коду ініціалізації із зручної init()для вас нової допоміжної функції foo(), зателефонуйте, foo(...)щоб виконати ініціалізацію у своєму підкласі.

Подивіться на WWDC-відео "403 проміжний Свіфт" о 18:30 для детального пояснення ініціалізаторів та їх успадкування. Як я зрозумів, розглянемо наступне:

class Dragon {
    var legs: Int
    var isFlying: Bool

    init(legs: Int, isFlying: Bool) {
        self.legs = legs
        self.isFlying = isFlying
    }

    convenience initWyvern() { 
        self.init(legs: 2, isFlying: true)
    }
}

Але тепер розглянемо підклас Вирма: Вирм - це Дракон без ніг і крил. Тож Ініціалізатор для Віверна (2 ноги, 2 крила) для нього неправильний! Цю помилку можна уникнути, якщо зручний Wyvern-Initializer просто неможливо викликати, а лише повністю призначений Initializer:

class Wyrm: Dragon {
    init() {
        super.init(legs: 0, isFlying: false)
    }
}

Чому б у вас просто не було двох ініціалізаторів - один зі значенням за замовчуванням?

class A {
  var x: Int

  init(x: Int) {
    self.x = x
  }

  init() {
    self.x = 0
  }
}

class B: A {
  override init() {
    super.init()

    // Do something else
  }
}

let s = B()
s.x // 0