Existe-t-il un moyen standard de créer une "fonction virtuelle pure" dans Swift, ie. celui qui doit être remplacé par chaque sous-classe, et qui, si ce n'est pas le cas, provoque une erreur de compilation?

Vous avez deux options:

1. Utilisez un protocole

Définir la superclasse comme un protocole au lieu d'une classe

Pro : vérification du temps de compilation pour savoir si chaque "sous-classe" (pas une sous-classe réelle) implémente la ou les méthodes requises

Inconvénient : la "superclasse" (protocole) ne peut pas implémenter de méthodes ou de propriétés

2. Affirmer dans la super version de la méthode

Exemple:

class SuperClass {
    func someFunc() {
        fatalError("Must Override")
    }
}

class Subclass : SuperClass {
    override func someFunc() {
    }
}

Pro : Peut implémenter des méthodes et des propriétés en superclasse

Inconvénient : pas de vérification du temps de compilation

Ce qui suit permet d'hériter d'une classe et aussi de vérifier l'heure de compilation du protocole :)

protocol ViewControllerProtocol {
    func setupViews()
    func setupConstraints()
}

typealias ViewController = ViewControllerClass & ViewControllerProtocol

class ViewControllerClass : UIViewController {

    override func viewDidLoad() {
        self.setup()
    }

    func setup() {
        guard let controller = self as? ViewController else {
            return
        }

        controller.setupViews()
        controller.setupConstraints()
    }

    //.... and implement methods related to UIViewController at will

}

class SubClass : ViewController {

    //-- in case these aren't here... an error will be presented
    func setupViews() { ... }
    func setupConstraints() { ... }

}

Il n'y a pas de support pour la classe abstraite / les fonctions virtuelles, mais vous pouvez probablement utiliser un protocole dans la plupart des cas:

protocol SomeProtocol {
    func someMethod()
}

class SomeClass: SomeProtocol {
    func someMethod() {}
}

Si SomeClass n'implémente pas someMethod, vous obtiendrez cette erreur de compilation:

error: type 'SomeClass' does not conform to protocol 'SomeProtocol'

Une autre solution de contournement, si vous n'avez pas trop de méthodes "virtuelles", consiste à demander à la sous-classe de passer les "implémentations" dans le constructeur de classe de base en tant qu'objets de fonction:

class MyVirtual {

    // 'Implementation' provided by subclass
    let fooImpl: (() -> String)

    // Delegates to 'implementation' provided by subclass
    func foo() -> String {
        return fooImpl()
    }

    init(fooImpl: (() -> String)) {
        self.fooImpl = fooImpl
    }
}

class MyImpl: MyVirtual {

    // 'Implementation' for super.foo()
    func myFoo() -> String {
        return "I am foo"
    }

    init() {
        // pass the 'implementation' to the superclass
        super.init(myFoo)
    }
}

Vous pouvez utiliser protocole vs assertion comme suggéré dans la réponse ici par drewag. Cependant, l'exemple du protocole est manquant. Je couvre ici,

Protocole

protocol SomeProtocol {
    func someMethod()
}

class SomeClass: SomeProtocol {
    func someMethod() {}
}

Désormais, toutes les sous-classes doivent implémenter le protocole qui est vérifié au moment de la compilation. Si SomeClass n'implémente pas someMethod, vous obtiendrez cette erreur de compilation:

erreur: le type 'SomeClass' n'est pas conforme au protocole 'SomeProtocol'

Remarque: cela ne fonctionne que pour la classe la plus élevée qui implémente le protocole. Toutes les sous-classes peuvent ignorer allègrement les exigences du protocole. - comme commenté parmemmons

Affirmation

class SuperClass {
    func someFunc() {
        fatalError("Must Override")
    }
}

class Subclass : SuperClass {
    override func someFunc() {
    }
}

Cependant, l'assertion ne fonctionnera que pendant l'exécution.

Étant nouveau dans le développement iOS, je ne sais pas vraiment quand cela a été implémenté, mais une façon d'obtenir le meilleur des deux mondes est d'implémenter une extension pour un protocole:

protocol ThingsToDo {
    func doThingOne()
}

extension ThingsToDo {
    func doThingTwo() { /* Define code here */}
}

class Person: ThingsToDo {
    func doThingOne() {
        // Already defined in extension
        doThingTwo()
        // Rest of code
    }
}

L'extension est ce qui vous permet d'avoir la valeur par défaut pour une fonction tandis que la fonction dans le protocole régulier fournit toujours une erreur de compilation si elle n'est pas définie