À quel moment et dans quelles conditions la gestion…

La dispatch de méthodes (method dispatch) en Swift détermine quel code sera exécuté lors de l'appel d'une méthode d'un objet. Le type de dispatch est choisi lors de la compilation du code Swift.

Il existe trois principaux types de dispatch en Swift :

Dispatch direct (Direct Dispatch) :
- Le plus rapide.
- L'adresse de la fonction est connue lors de la compilation.
- Utilisé par défaut pour :
  - struct et enum (car ils ne supportent pas l'héritage de classes).
  - Méthodes final de classes.
  - Méthodes private de classes (internal et public ne supportent pas le dispatch direct).
  - Fonctions globales.
  - Méthodes statiques.
  - Extensions.
Dispatch par table (Table Dispatch) :
- Utilisé pour class, lorsque le polymorphisme et l'héritage sont nécessaires.
- L'adresse de l'implémentation spécifique de la méthode est déterminée à l'exécution (runtime) en utilisant la table des méthodes virtuelles (vtable - Virtual Table).
- Chaque classe possède sa propre vtable, contenant des pointeurs vers les implémentations des méthodes.
- Supporte l'héritage et la redéfinition des méthodes.
```
class Animal { // S'appliquera le dispatch par table
    func speak() {
        print("Son de son inconnu")
    }
}

class Dog: Animal { // Redéfinition, utilise la vtable
    override func speak() {
        print("Wouf")
    }
}
```
Dispatch par table de témoins (Witness Table Dispatch) :
- Utilisé pour les protocoles (protocol).
- Semblable au dispatch par table, mais utilise une table de témoins (witness table) pour rechercher l'implémentation de la méthode du protocole pour un type spécifique.
- Permet le polymorphisme avec les protocoles.
```
protocol Speakable { // S'appliquera le dispatch par table de témoins
    func speak()
}

struct Cat: Speakable { // Implémentation du protocole
    func speak() {
        print("Miaou")
    }
}
```

Conditions influençant le choix :

Type de données : struct, enum, class, protocol.
Modificateurs d'accès : final, private, internal, public.
Héritage : Capacité de redéfinir des méthodes.
Conformité aux protocoles : Implémentation des méthodes du protocole.
Contexte d'appel : Appel via un type concret ou via un protocole/classe de base.

Le compilateur Swift essaie d'utiliser le dispatch direct lorsque cela est possible pour optimiser la performance, mais en cas de besoin de support pour le polymorphisme et l'héritage, il passe au dispatch par table ou par table de témoins. La déclaration explicite de méthodes comme final ou private permet de forcer l'utilisation du dispatch direct.

À quel moment et dans quelles conditions la gestion commence-t-elle à fonctionner dans Swift?