Quel principe de programmation permet d'utiliser des génériques?

Polymorphisme de sous-types.

Les génériques en Swift implémentent le polymorphisme paramétrique, permettant d’écrire du code qui peut fonctionner avec différents types sans les connaître à l’avance, mais en exigeant que ces types respectent certaines contraintes (par exemple, des protocoles).

Exemple d’utilisation des génériques :

// Définition d’une fonction générique qui accepte deux paramètres du même type T,
// où le type T doit respecter le protocole Equatable.
func areEqual<T: Equatable>(_ a: T, _ b: T) -> Bool {
    return a == b
}

// Utilisation de la fonction générique avec Int
let intResult = areEqual(5, 5) // true

// Utilisation de la fonction générique avec String
let stringResult = areEqual("hello", "world") // false

Exemple de structure générique (pile) :

// Définition d’une structure générique "Stack", qui peut stocker des éléments de n’importe quel type T.
struct Stack<T> {
    private var elements: [T] = []

    mutating func push(_ element: T) {
        elements.append(element)
    }

    mutating func pop() -> T? {
        return elements.popLast()
    }
}

// Utilisation de la structure générique avec Int
var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
let poppedInt = intStack.pop() // 2

// Utilisation de la structure générique avec String
var stringStack = Stack<String>()
stringStack.push("A")
stringStack.push("B")
let poppedString = stringStack.pop() // "B"

Avantages de l’utilisation des génériques :

• Sécurité des types : Le compilateur vérifie les types lors de la compilation, réduisant la probabilité d’erreurs à l’exécution.
• Réutilisation du code : Le même code peut fonctionner avec différents types.
• Performance : Il n’est pas nécessaire de faire des conversions de types à l’exécution.
• Abstraction : Permettent de s’abstraire des types de données spécifiques.