Perché gli inizializzatori Swift non possono chiamare inizializzatori di convenienza sulla loro superclasse?

Considera le due classi:

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

Non vedo perché questo non è permesso. In ultima analisi, inizializzatore designato di ogni classe viene chiamato con tutti i valori di cui hanno bisogno, quindi perché devo ripetermi in B's initspecificando un valore predefinito per xancora una volta, quando la convenienza inita Afarà bene?

Questa è la regola 1 delle regole "Initializer Chaining" come specificato nella Swift Programming Guide, che recita:

Regola 1: gli inizializzatori designati devono chiamare un inizializzatore designato dalla loro superclasse immediata.

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

Enfasi mia. Gli inizializzatori designati non possono chiamare inizializzatori di convenienza.

C'è un diagramma che accompagna le regole per dimostrare quali "direzioni" dell'inizializzatore sono consentite:

Ritenere

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

Poiché tutti gli inizializzatori designati di classe A vengono sovrascritti, la classe B erediterà tutti gli inizializzatori di convenienza di A. Quindi l'esecuzione di questo produrrà

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

Ora, se l'inizializzatore designato B.init (a: b :) fosse autorizzato a chiamare l'inizializzatore di convenienza della classe base A.init (a :), ciò risulterebbe in una chiamata ricorsiva a B.init (a:, b: ).

È perché puoi finire con una ricorsione infinita. Ritenere:

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

e guarda:

let a = SubClass()

chi chiamerà SubClass.init()chi chiamerà SuperClass.init(value:)chi chiamerà SubClass.init().

Le regole di inizializzazione designate / convenienza sono progettate in modo che l'inizializzazione di una classe sarà sempre corretta.

Ho trovato una soluzione per questo. Non è super carino, ma risolve il problema di non conoscere i valori di una superclasse o di voler impostare valori predefiniti.

Tutto quello che devi fare è creare un'istanza della superclasse, usando la comodità init, proprio nella initsottoclasse. Quindi chiami il designato initdel super usando l'istanza che hai appena creato.

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

Prendi in considerazione l'estrazione del codice di inizializzazione dalla tua comoda init()a una nuova funzione di supporto foo(), chiama foo(...)per eseguire l'inizializzazione nella tua sottoclasse.

Guarda il video WWDC "403 intermedio Swift" alle 18:30 per una spiegazione approfondita degli inizializzatori e della loro eredità. A quanto ho capito, considera quanto segue:

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

Ma ora considera una sottoclasse Wyrm: un Wyrm è un drago senza gambe e senza ali. Quindi l'inizializzatore per una viverna (2 gambe, 2 ali) è sbagliato! Questo errore può essere evitato se non è possibile chiamare la convenienza Wyvern-Initializer ma solo l'inizializzatore designato completo:

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

Perché non hai solo due inizializzatori, uno con un valore predefinito?

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