Introduction au Polymorphisme

Types de Polymorphisme

Il existe deux principaux types de polymorphisme : à la compilation (statique) et à l'exécution (dynamique). Comprendre les nuances et les applications de chaque type de polymorphisme est crucial pour écrire du code robuste et adaptable.

Polymorphisme à la Compilation : Ceci est réalisé en utilisant la surcharge de fonctions et la surcharge d'opérateurs, où la fonction à exécuter est déterminée lors de la compilation.
Polymorphisme à l'Exécution : Ceci est principalement réalisé grâce à l'utilisation de fonctions virtuelles, permettant à une fonction d'être redéfinie dans des classes dérivées et à son comportement d'être déterminé à l'exécution.

Remarque

Dans ce cours, nous allons plonger profondément dans le polymorphisme à l'exécution, car il représente l'un des paradigmes fondamentaux de la programmation orientée objet. De plus, nous aborderons le polymorphisme à la compilation dans le contexte des classes.

Application et besoin de polymorphisme

Une excellente façon de comprendre le polymorphisme est à travers une analogie du monde réel. Considérez une interface utilisateur graphique avec un bouton. Ce bouton peut être utilisé dans différents contextes : comme un bouton de téléchargement, un bouton de réinitialisation, ou un bouton d'annulation.

Chaque bouton exécute une action distincte lorsqu'il est cliqué, mais ils servent tous essentiellement de boutons. Regardez l'implémentation théorique de ce concept.

UploadButton

ResetButton

CancelButton


              1234
            
class UploadButton : public Button {
public:
    void onClick() { std::cout << "Upload" << std::endl; }  
};

Étant donné que tous les boutons partagent la même méthode onClick() avec des implémentations variées, plongeons plus profondément. Que se passe-t-il si nous avons besoin d'une fonction qui accepte un objet appartenant à l'une des classes de boutons comme paramètre ?

main


              1234567891011
            
void user_clicked_upload_button(const UploadButton& btn) {
    btn.onClick();
}

void user_clicked_reset_button(const ResetButton& btn) {
    btn.onClick();
}

void user_clicked_cancel_button(const CancelButton& btn) {
    btn.onClick();
}

Comme vous pouvez le voir, créer manuellement des fonctions séparées pour chaque bouton peut créer de la complexité, surtout lors des modifications, car chaque fonction doit être modifiée individuellement si des problèmes surviennent. De plus, dans la fonction principale, des vérifications supplémentaires seront nécessaires pour déterminer quelle fonction appeler. Le polymorphisme permet de résoudre facilement ces problèmes.

Tout était clair ?

Merci pour vos commentaires !

Section 5. Chapitre 1