Warum können Swift-Initialisierer in ihrer Oberklasse keine Convenience-Initialisierer aufrufen?

Betrachten Sie die beiden Klassen:

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'
    }
}

Ich verstehe nicht, warum das nicht erlaubt ist. Letztendlich wird der von jeder Klasse festgelegte Initialisierer mit allen benötigten Werten aufgerufen. Warum muss ich mich also wiederholen B, initindem ich einen Standardwert für xerneut spezifiziere , wenn die Bequemlichkeit initin Agut ist?

Dies ist Regel 1 der Regeln für die "Initializer-Verkettung", wie im Swift-Programmierhandbuch angegeben:

Regel 1: Bestimmte Initialisierer müssen einen bestimmten Initialisierer aus ihrer unmittelbaren Oberklasse aufrufen .

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

Hervorhebung von mir. Bestimmte Initialisierer können keine praktischen Initialisierer aufrufen.

Es gibt ein Diagramm, das den Regeln entspricht, um zu demonstrieren, welche "Anweisungen" des Initialisierers zulässig sind:

Erwägen

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()

Da alle festgelegten Initialisierer der Klasse A überschrieben werden, erbt die Klasse B alle praktischen Initialisierer von A. Wenn Sie dies ausführen, wird dies ausgegeben

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

Wenn der angegebene Initialisierer B.init (a: b :) den Basisklassen-Convenience-Initialisierer A.init (a :) aufrufen darf, führt dies zu einem rekursiven Aufruf von B.init (a :, b :. ).

Es ist, weil Sie mit einer unendlichen Rekursion enden können. Erwägen:

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)
    }
}

und schau dir an:

let a = SubClass()

was wird anrufen SubClass.init() welches anruft SuperClass.init(value:)welches anruft SubClass.init().

Die festgelegten / praktischen Initialisierungsregeln sind so konzipiert, dass eine Klasseninitialisierung immer korrekt ist.

Ich habe eine Lösung dafür gefunden. Es ist nicht besonders hübsch, aber es löst das Problem, die Werte einer Oberklasse nicht zu kennen oder Standardwerte festlegen zu wollen.

Alles, was Sie tun müssen, ist, eine Instanz der Oberklasse zu erstellen, indem Sie die Bequemlichkeit initdirekt in initder Unterklasse verwenden. Dann rufen Sie den designierten initSuper mit der gerade erstellten Instanz auf.

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) 
    }
}

Ziehen Sie in Betracht, den Initialisierungscode von Ihrer praktischen init()zu einer neuen Hilfsfunktion zu extrahieren foo(), und rufen Sie foo(...)auf, um die Initialisierung in Ihrer Unterklasse durchzuführen.

Schauen Sie sich das WWDC-Video "403 Intermediate Swift" um 18:30 an, um eine ausführliche Erklärung der Initialisierer und ihrer Vererbung zu erhalten. Beachten Sie nach meinem Verständnis Folgendes:

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)
    }
}

Aber jetzt betrachten wir eine Wyrm-Unterklasse: Ein Wyrm ist ein Drache ohne Beine und ohne Flügel. Der Initializer für einen Wyvern (2 Beine, 2 Flügel) ist also falsch! Dieser Fehler kann vermieden werden, wenn der bequeme Wyvern-Initializer einfach nicht aufgerufen werden kann, sondern nur der vollständig festgelegte Initializer:

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

Warum haben Sie nicht einfach zwei Initialisierer - einen mit einem Standardwert?

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