- Encapsulation et Extension des Types
- Héritage
- Polymorphisme
- Surcharge
- Fonctions virtuelles
- Membres Statiques de Classe
- Templates de fonctions
- Templates de classes
- Abstract Classes
Polymorphisme
Le polymorphisme est l'opportunité pour différentes classes d'objets, liées entre elles par un héritage, de répondre de différentes façons lors de l'appel à la même fonction. Il aide à créer un mécanisme universel décrivant le comportement non seulement de la classe de base, mais aussi des classes descendantes.
Continuons à développer une classe de base CShape, et définissons une fonction membre GetArea(), conçue pour calculer l'aire d'une forme. Dans toutes les classes descendantes, produites par héritage depuis la classe de base, nous redéfinissons cette fonction selon les règles de calcul de l'aire d'une forme particulière.
Pour un carré (classe CSquare), l'aire est calculée grâce à ses côtés, pour un cercle (class CCircle), l'aire est exprimée grâce à son rayon, etc. Nous pouvons créer un tableau pour stocker des objets de type CShape, dans lesquels à la fois des objets de la classe de base et ceux des classes descendantes peuvent être stockés. Par la suite, nous pourrons appeler la même fonction pour tous les éléments du tableau.
Exemple :
//--- Classes de base
|
Maintenant, toutes les classes dérivées ont une fonction membre getArea(), qui retourne une valeur zéro. L'implémentation de cette fonction variera dans chaque descendant.
//--- La classe dérivée Circle
|
Pour la classe Carré, la déclaration est identique :
//--- La classe dérivée Carré
|
Pour calculer l'aire du carré et du cercle, nous avons besoin des valeurs correspondantes de m_radius et de m_square_side, nous avons donc ajouté les fonctions SetRadius() et SetSide() dans la déclaration de la classe correspondante.
Il est assumé que des objets de types différents (CCircle et CSquare) dérivés du même type de base CShape, sont utilisés dans notre programme. Le polymorphisme permet de créer un tableau d'objets de la classe de base CShape, mais lors de la déclaration de ce tableau, ces objets ne sont pas encore connus et leurs types sont indéfinis.
La décision sur quel type d'objet sera contenu dans chaque élément du tableau sera prise directement pendant l'exécution du programme. Ceci implique la création dynamique des objets des classes correspondantes, et donc la nécéssité d'utiliser d'utiliser des pointeurs d'objet au lieu des objets directement.
L'opérateur new est utilisé pour créer dynamiquement les objets. Chaque objet doit ensuite être supprimé individuellement et explicitement en utilisant l'opérateur delete. Nous déclarerons donc un tableau de pointeurs de type CShape, et nous créerons un objet du bon type pour chaque élément (new Class_Name), comme montré dans l'exemple du script suivant :
//+------------------------------------------------------------------+
|
Veuillez noter que lors de la suppression d'un objet avec l'opérateur delete, le type de son pointeur doit être vérifié. Seuls les objets avec un pointeur de type POINTER_DYNAMIC peuvent être supprimés avec delete. Pour les pointeurs d'autres types, une erreur sera retournée.
Mais outre la redéfinition des fonctions pendant l'héritage, le polymorphisme inclut également l'implémentation d'une même fonction avec différents ensembles de paramètres dans une classe. Cela signifie que la classe peut avoir plusieurs fonctions avec le même nom mais avec un type différent et/ou un ensemble de paramères différent. Dans ce cas, le polymorphisme est implémenté via la surcharge de fonction.
Voir aussi