Tutorial C++ : La dérivation simple

Théorie:

Supposons que l'on désire créer des listes telles qu'elles ne contiennent pas de répétition. Une solution serait de réécrire complètement une classe pour cela. Cependant, se faisant, nous ne profitons pas de la classe liste déjà existante et des fonctions qui restent valides: constructeurs, destructeurs, opérateurs, etc. Seule la méthode ajoute doit être modifiée.

La solution consiste donc à considérer une liste sans répétition comme une liste et de redéfinir certaines fonctions. C'est ce que l'on appelle "dériver la classe liste". La nouvelle classe hérite des données et des méthodes de sa classe de base, ce qui définit un comportement par défaut.

Une classe peut dériver de plusieurs classes de base. Par exemple, une classe ambulance pourrait dériver des classes voitures et véhicule_d_urgence.

Pratique:

Les classes de base d'une classe se déclarent ainsi:

class nom_classe_dérivée: public nom_clase_base1, nom_clase_base2, ...

{

// Déclarations habituelles

};

La classe dérivée a alors accès aux parties publiques des classes de base. Pour les parties cachées, il y a deux possibilités:

1. si la partie cachée a été déclarée private, la classe dérivée n'y a pas accès,

2. si la partie cachée a été déclarée protected, la classe dérivée y a accès.

Dans le cas où la dérivation est publique, comme dans l'exemple précédent, les propriétés de protection (public, protected ou private) ne sont pas modifiées. Si la dérivation est protégée - utilisation du mot clé protected - les membres publiques ou protégés de la classe de base deviennent protégés dans la classe dérivée. Enfin, si la dérivation est privée - utilisation du mot clé private - les membres de la classe de base deviennent privés dans la classe dérivée. La dérivation publique est la plus utilisée.

Il est alors possible de redéfinir des méthodes existantes dans les classes de base afin de modifier leur comportement, ou de créer de nouvelles méthodes spécialisées pour la nouvelle classe.

Lors de la construction d'un objet d'une classe dérivée, il ya appel aux constructeurs des classes de base avant l'appel au constructeur de la classe dérivée. Des arguments peuvent être passés à ces constructeurs de la manière suivante:

constructeur_derive(argument1, ..., argumentN) : constructeur_base1(argumentX, argumentY, ...), constructeur_base2(...), ... .

L'ordre des appels des constructeurs des classes n'est pas connu. Lors de la destruction des objets d'une classe dérivée, il y a appel aux destructeurs des classes de base dans l'ordre inverse de celui des constructeurs.

Exemple:

Déclaration d'une classe pour lister des entiers sans répétition

class liste_sans_rep: public liste
{
public:


// Constructeurs
liste_sans_rep();
liste_sans_rep(liste_sans_rep&);


// Fonction ajoute redéfinie
booleen ajoute(int);


// Nouvelle fonction testant si un élément appartient à la liste
booleen est_dans_liste(int);


// Destructeur
~liste_sans_rep();
};


liste_sans_rep::liste_sans_rep(): liste()
{ }


liste_sans_rep::liste_sans_rep(liste_sans_rep& list): liste(list)
{ }


booleen liste_sans_rep::est_dans_liste(int element)
{
maillon *index;


for(index=debut_liste;index!=NULL;index=index->suivant)
if(index->valeur == element)
return VRAI;


return FAUX;
}


booleen liste_sans_rep::ajoute(int element)
{
if (est_dans_liste(element))
return FAUX;


// Appel explicite à la fonction ajoute de la classe de base liste
return liste::ajoute(element);
}


liste_sans_rep::~liste_sans_rep()
{ }