Réutilisation du code

Imaginons qu’on vous a fourni une bibliothèque de formes graphiques contenant par exemple une classe rectangle ayant l’allure suivante :

class rectangle {     // membres privés     public :     rectangle();     rectangle(int gche, int haut, int drte, int bas);     ~rectangle();     void trace();     void efface();     void valeur(int& gche, int& haut,                 int& drte, int& bas);     void change(int gche, int haut,                 int drte, int bas);     };

Vous ne connaissez pas les membres privés (même si vous les connaissiez vous ne pourriez pas les changer, ils sont définitivement hors de portée), ni le code des méthodes dont vous connaissez simplement le nom et l’usage : valeur donne les coordonnées des bords du rectangle, change les modifie, trace dessine le rectangle à l’écran tandis que efface le supprime ; le constructeur par défaut crée un rectangle vide, l’autre crée un rectangle dont on fournit les coordonnées des bords.

A présent, vous souhaitez créer une classe qui ne se trouve pas dans la bibliothèque, et représente un rectangle plein (avec une couleur de remplissage). Il est clair que la plupart des méthodes de rectangle s’appliquent à notre nouvelle classe, et qu’il faut simplement ajouter un champ indiquant la couleur de remplissage, plus deux méthodes couleur qui permettent de connaître cette couleur et de la modifier ; il faut aussi changer trace et efface.

Pour cela, nous allons écrire que notre nouvelle classe rectplein est en fait un rectangle, plus quelque chose. Cela s’écrit ainsi :

class rectplein : rectangle {     int coul;     public :     rectplein();     rectplein(int gche, int haut,             int drte, int bas, int couleur = 0);     ~rectplein();     void trace(void);     void efface();     int couleur() { return coul; }    // donne couleur     int couleur(int nouvelle)         {        // donne la couleur et la change             int ancienne = coul;             coul = nouvelle;             trace();             return ancienne;         }     };

On dit que l’on a dérivé la classe rectplein de rectangle. Dans ce cas, la classe dérivée hérite des caractéristiques de la classe de base, et en particulier de ses membres. Dans certains cas, les membres de la classe de base doivent être redéfinis (cas de trace et efface notamment), dans d’autres les méthodes de la classe de base conviennent aussi (cas de change et valeur dans notre exemple).

La classe dérivée peut utiliser les membres publics de la classe de base, même si elle les redéfinit. Par exemple, la fonction trace de rectplein se réduit à deux opérations : remplir le rectangle avec la couleur de remplissage, puis dessiner le bord de ce rectangle. Si l’on suppose qu’on dispose d’une fonction remplirrect réalisant le premier travail, il suffit d’écrire :

void rectplein::trace(void){     if (coul) {         int gche, drte, haut bas;         valeur(gche, haut, drte, bas);         remplirrect(gche, haut, drte, bas, coul);         }     rectangle::trace();}

On a appelé la méthode valeur héritée de rectangle (puisqu’on ne connaît pas les coordonnées du rectangle qui sont des membres privés de la classe de base) ainsi que la méthode trace de rectangle ; dans ce dernier cas, il faut absolument écrire rectangle::trace() et non trace() qui ferait un appel récursif infini.

Précédent

Sommaire

Suivant