Pourquoi les initialiseurs Swift ne peuvent-ils pas appeler les initialiseurs de commodité sur leur superclasse?

Considérez les deux classes:

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

Je ne vois pas pourquoi ce n'est pas autorisé. En fin de compte, l'initialiseur désigné de chaque classe est appelée avec toutes les valeurs dont ils ont besoin, alors pourquoi dois - je me répéter dans B« s initen spécifiant une valeur par défaut de xnouveau, lorsque la commodité initen Afera très bien?

Il s'agit de la règle 1 des règles "Initializer Chaining" comme spécifié dans le Guide de programmation Swift, qui se lit comme suit:

Règle 1: les initialiseurs désignés doivent appeler un initialiseur désigné à partir de leur superclasse immédiate.

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

Soulignez le mien. Les initialiseurs désignés ne peuvent pas appeler les initialiseurs pratiques.

Il existe un diagramme qui accompagne les règles pour montrer quelles "directions" d'initialisation sont autorisées:

Considérer

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

Étant donné que tous les initialiseurs désignés de la classe A sont remplacés, la classe B héritera de tous les initialiseurs de commodité de A. Donc, l'exécution de ceci produira

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

Maintenant, si l'initialiseur désigné B.init (a: b :) était autorisé à appeler l'initialiseur de commodité de classe de base A.init (a :), cela entraînerait un appel récursif à B.init (a:, b: ).

C'est parce que vous pouvez vous retrouver avec une récursion infinie. Considérer:

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

et regardez:

let a = SubClass()

qui appellera SubClass.init()qui appellera SuperClass.init(value:)qui appellera SubClass.init().

Les règles d'initialisation désignées / pratiques sont conçues pour qu'une initialisation de classe soit toujours correcte.

J'ai trouvé une solution pour cela. Ce n'est pas super joli, mais cela résout le problème de ne pas connaître les valeurs d'une superclasse ou de vouloir définir des valeurs par défaut.

Tout ce que vous avez à faire est de créer une instance de la superclasse, en utilisant la commodité init, directement dans initla sous-classe. Ensuite, vous appelez le désigné initdu super en utilisant l'instance que vous venez de créer.

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

Pensez à extraire le code d'initialisation de votre pratique init()vers une nouvelle fonction d'assistance foo(), appelez foo(...)pour effectuer l'initialisation dans votre sous-classe.

Regardez la vidéo WWDC "403 intermediaire Swift" à 18h30 pour une explication détaillée des initialiseurs et de leur héritage. D'après ce que j'ai compris, considérez ce qui suit:

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

Mais maintenant, considérez une sous-classe Wyrm: Un Wyrm est un Dragon sans pattes et sans ailes. Donc l'initialiseur pour un Wyvern (2 pattes, 2 ailes) est faux! Cette erreur peut être évitée si la commodité Wyvern-Initializer ne peut tout simplement pas être appelée, mais uniquement l'initialiseur désigné complet:

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

Pourquoi n'avez-vous pas simplement deux initialiseurs - un avec une valeur par défaut?

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