Le Polymorphisme

Le Polymorphisme est un terme grec qui signifie plusieurs formes. Il est utilisé en langage C++ pour permettre à un code d’être utilisé avec différents types. Et l’un de plus grands avantages du polymorphisme est que le fait d'utiliser un même nom de méthode pour plusieurs types d'objets différents, permet au programmeur de ne pas se soucier du type précis de l’objet que la méthode va s’appliquer lorsqu'il programme cette dernière.

Avant de lire ce cours, il est recommandé que vous ayez une bonne notion sur les pointeurs et l'héritage de classe. Si l'un de ces notions vous paraît étrange, vous devriez retourner lire les cours concernés.

Le polymorphisme est une notion très importante en langage C++. Il fait partie des piliers de la programmation orienté objet. Tout programmeur POO doit avoir une maitrise parfaite du polymorphisme. Il est une notion qu’il faut traiter avec attention. Cependant je dois vous dire qu’elle est la notion la plus compliquée en POO ; mais on va aller molo molo pour que chacun puisse comprendre.

Le polymorphisme est relatif aux méthodes des objets. Or en C++, une méthode n’est pas polymorphe. Pour pouvoir la rendre polymorphe, il faut commencer par déclarer une méthode virtuelle dans la classe mère et puis par la suite la redéfinir en respectant la même signature dans les classes dérivées.

Il ne faut pas oublier que le langage C++ exige que chaque classe ayant une méthode virtuelle ait un destructeur virtuel.

Maintenant entrons dans la salle de gym d’informatique.

Les machines sont déjà allumées ?

Commençons par faire quelque chose qui ne devrait pas nous effrayer : quelque chose qui n’est pas nouveau pour nous.

Nous allons créer une classe Parallelepipede permettant de calculer les volumes de certaines figures géométriques. Bien évidement nous allons créer des pointeurs pointant vers des objets de celle-ci.

Code C++:
#include <iostream> #include <cstdlib> using namespace std; class Parallelepipede { protected: int longueur, largeur, hauteur; public: void dimensions (int L, int l, int h) { longueur=L; largeur=l, hauteur=h; } }; class Cube: public Parallelepipede { public: int volume () { return (longueur * largeur * hauteur); } }; class parallelepipede_rectangle: public Parallelepipede { public: int volume () { return (longueur * largeur * hauteur); } }; int main () { Cube cube; parallelepipede_rectangle parect; Parallelepipede * pParapiped1 = &cube; Parallelepipede * pParapiped2 = &parect; pParapiped1->dimensions (4,4,4); pParapiped2->dimensions (8,5,2); cout << cube.volume() << endl; cout << parect.volume() << endl; system("pause"); return 0; }

Comme vous voyez, dans la fonction main, nous avons créé deux pointeurs (pParapiped1 et pParapiped2) qui pointent vers des objets de la classe Parallelepipede. Et nous avons attribué à des références (cube et parect) à ces pointeurs tout simplement parce qu’ils sont des objets dérivés de la classe Parallelepipede.
* pParapiped1 et * pParapiped2 sont de type Parallelepipede * et nous ne pouvons seulement les utiliser que pour les membres de la classe Parallelepipede que héritent cube et parallelepipede_rectangle. Et pour résoudre ce problème, nous allons déclarer une méthode virtuelle dans la classe de base.

Méthode virtuelle

Pour déclarer une fonction membre virtuelle, on utilise le mot clé virtual. Si une fonction est déclarée virtuelle dans la classe de base, elle est virtuelle dans toutes les classes dérivées. En déclarant une méthode virtuelle dans la fonction de base, toutes les fonctions des classes dérivées dont la signature correspond à celle de la déclaration dans la classe de base seront appelées en utilisant le mécanisme virtuel. Et c’est cela qui rend la méthode polymorphe.

Nous allons reprendre notre code en y ajoutant la méthode virtuelle (volume) dans la classe de base.
Code :
#include <iostream> #include <cstdlib> using namespace std; class Parallelepipede { protected: int longueur, largeur, hauteur; public: void dimensions (int L, int l, int h) { longueur=L; largeur=l, hauteur=h; } virtual int volume () { return (0);} }; class Cube: public Parallelepipede { public: int volume () { return (longueur * largeur * hauteur); } }; class parallelepipede_rectangle: public Parallelepipede { public: int volume () { return (longueur * largeur * hauteur); } }; int main () { Cube cube; parallelepipede_rectangle parect; Parallelepipede * pParapiped1 = &cube; Parallelepipede * pParapiped2 = &parect; pParapiped1->dimensions (4,4,4); pParapiped2->dimensions (8,5,2); cout << pParapiped1->volume() << endl; cout << pParapiped2->volume() << endl; system("pause"); return 0; }

Et voila maintenant les classes Parallelepipede, cube et parallelepipede_rectangle ont les même membres (longueur, largeur, hauteur, volume, et dimensions). Il suffit de supprimer le mot clé virtual se trouvant dans la classe de base (Parallelepipede) pour avoir des faux résultats (0 partout).

Le but d’utilisation du mot clé virtual est de permettre à un membre d’une classe dérivée avec le même nom que celui de la classe de base d’être appelé à partir d’un pointeur. Pas n’importe quel pointeur, mais un pointeur vers la classe de base qui est pointé vers un objet de la classe dérivée.

Une classe qui déclare une fonction virtuelle ou qui hérite d’une fonction virtuelle est appelée classe polymorphe.

Une question? Cliquez ici pour la poser.

Retour sur le portail du langage C/C++