Esiste un modo standard per creare una "funzione virtuale pura" in Swift, ad es. uno che deve essere sovrascritto da ogni sottoclasse e che, se non lo è, causa un errore in fase di compilazione?

Hai due opzioni:

1. Utilizzare un protocollo

Definisci la superclasse come protocollo invece che come classe

Pro : verifica del tempo di compilazione se ogni "sottoclasse" (non una sottoclasse effettiva) implementa i metodi richiesti

Contro : la "superclasse" (protocollo) non può implementare metodi o proprietà

2. Affermare nella versione super del metodo

Esempio:

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

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

Pro : può implementare metodi e proprietà in una superclasse

Contro : nessun controllo del tempo di compilazione

Quanto segue consente di ereditare da una classe e anche di controllare il tempo di compilazione del protocollo :)

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() { ... }

}

Non c'è alcun supporto per classi astratte / funzioni virtuali, ma probabilmente potresti usare un protocollo per la maggior parte dei casi:

protocol SomeProtocol {
    func someMethod()
}

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

Se SomeClass non implementa someMethod, riceverai questo errore in fase di compilazione:

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

Un'altra soluzione alternativa, se non si hanno troppi metodi "virtuali", è fare in modo che la sottoclasse passi le "implementazioni" nel costruttore della classe base come oggetti funzione:

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

Puoi usare protocollo vs asserzione come suggerito nella risposta qui da drewag. Tuttavia, manca un esempio per il protocollo. Sto coprendo qui,

Protocollo

protocol SomeProtocol {
    func someMethod()
}

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

Ora ogni sottoclasse è richiesta per implementare il protocollo che viene controllato in fase di compilazione. Se SomeClass non implementa someMethod, riceverai questo errore in fase di compilazione:

errore: il tipo "SomeClass" non è conforme al protocollo "SomeProtocol"

Nota: funziona solo per la classe più in alto che implementa il protocollo. Qualsiasi sottoclasse può ignorare allegramente i requisiti del protocollo. - come commentato damemmons

Asserzione

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

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

Tuttavia, l'asserzione funzionerà solo in runtime.

Essendo nuovo allo sviluppo iOS, non sono del tutto sicuro di quando questo è stato implementato, ma un modo per ottenere il meglio da entrambi i mondi è implementare un'estensione per un protocollo:

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'estensioneèquello che ti permette di avere il valore predefinito per una funzione mentre la funzione nel protocollo normale fornisce ancora un errore in fase di compilazione se non definita