IN204 Objets dérivés – Héritages et autres

IN204
Objets dérivés – Héritages et autres subtilités
Séance de Travaux Dirigés du 7 décembre 2006

IN204
Objets dérivés – La programmation par contrats
Séance de Travaux Dirigés du 14 décembre 2006
B. Monsuez
Exercice 1 – Définition et vérification du respect des
contrats (Un exemple sur une pile)
N
ous souhaitons définir un objet simulant une « pile » d’entiers de taille maximale n. Une pile
est vue comme une file d’éléments (ici des entiers) dont le nombre total d’éléments ne peut
j
amais dépasser le nombre maximal d’éléments défini par n.
Haut de la pile
Bas de la pile
Element 0
Haut de la pile
Element 3
Quand on ajoute un élément à la pile, on l’ajoute au dessus de tous les autres, c'est-à-dire au
dessus de (ou après) tous les éléments présents dans la pile.
Haut de la pile
Bas de la pile
Element 0
Haut de la pile
Element 3
Element 4
Ajout de l’élément :
Bas de la pile
Element 0
Haut de la pile
Element 3
Element 4
B. Monsuez
1ier Partie : La surcharge des compteurs
Vous trouverez dans le répertoire suivant ~bmonsuez/Pub/IN204/TD3/C++ un groupe de projets que
vous recopierez dans un répertoire local.

Ce projet correspond normalement à l’état dans lequel les classes ForwardCounter,
BackwardCounter devraient se trouver à la fin du TD précédent. Les élèves qui le souhaitent
peuvent reprendre leurs anciennes classes ForwardCounter, BackwardCounter en lieu et place
de celles définies dans ce projet.
Question n° 1 :
Nous souhaitons désormais modifier les compteurs en leur ajoutant une méthode virtuelle générique
« next » qui effectue une opération de comptage.
ForwardCounter implante une méthode « next » qui appelle la méthode « increment() »
BackwardCounter implante une méthode « next » qui appelle la méthode « decrement() ».
Question n° 2 :
Ecrire une fonction qui prendre comme paramètre une classe BaseCounter et qui fait appel à la
méthode « next » un certain nombre de fois.
Tester cette fonction avec des objets instances de ForwardCounter et BackwardCounter.
Question n° 3 :
Nous souhaitions modifier le comportement des compteurs. Actuellement, lorsque la valeur du
compteur de ForwardCounter atteint la valeur max, il recommence à compter à partir de la valeur
min.
Nous aimerions pouvoir rendre ce comportement « customizable ».
Pour ce faire, nous suggérons de modifier la méthode « increment() » de la manière suivante :
-. counter est plus petit que max alors incrémente counter.
-. counter est égal à max alors appelle une méthode virtuelle reachMaximum() qui décide ce qu’il
faut faire.
Modifier ForwardCounter afin d’implanter le comportement précédemment décrit.
Modifier de manière analogue BackwardCounter afin d’implanter le comportement précédemment
décrit (il s’agira de modifier la méthode decrement()).
Question n° 4 :
Dériver de la classe ForwardCounter une classe VerboseForwardCounter qui lorsque la
valeur maximale affiche un message avant de remettre la valeur du compteur à 0.
Vérifier son comportement.
2ième Partie : Ecriture d’algorithmes génériques
Dans la conclusion du cours, nous affirmons qu’un intérêt du polymorphisme, c’est de pouvoir écrire
un algorithme « générique », c’est à dire un algorithme qui pourra fonctionner pour des objets
représentant des données de plusieurs types.

Nous considérons un algorithme de tri très simple qui fonctionne sur des entiers :
int* tri(int* tableau, int taille)
{
for(int i=0; i<taille; i++)
{
for(int j=i+1; j<taille; j++)
{
if(tableau[i] > tableau[j])
{
int t = tableau[i];
tableau[i] = tableau[j];
tableau[j] = t;
}
}
}
return tableau;
}
Cet algorithme fonctionne uniquement pour des entiers. Nous nous proposons de transformer cette
fonction afin qu’elle puisse aussi bien trier des entiers mais aussi des réels ou des complexes.
Question n° 1 :
Pour ce faire, nous concevons une classe « abstraite » ayant comme nom « Base » qui expose les
fonctions nécessaires à l’écriture de l’algorithme de tri. Quelles sont les méthodes statiques et les
méthodes virtuelles que la classe abstraite doit exposer ?
Question n° 2 :
Compléter le squelette de la classe « abstraite » Base qui vous a été fourni.

Question n° 3 :
Créer une classe Entier qui dérive de la classe « abstraite » Base.
Initialiser un tableau de 100 entiers avec les valeurs allant de 100 à 1.
Question n° 4 :
Ecrire une fonction d’affichage qui affiche un tableau d’éléments de type « Base ». Tester cette
fonction avec le tableau d’entiers que vous avez créé à la question précédente.
Question n° 5 :
Modifier la fonction de tri afin de ne plus travailler sur des entiers mais sur des objets dérivant de la
classe « abstraite » Base.
Tester la fonction avec le tableau d’entiers que vous avez créé à la question n°3.
Question n° 6 :
Ecrire deux nouvelles classes Reel et Complexe stockant des nombres réels et complexes dérivant
de « Base ».
Vérifier que l’algorithme de tri fonctionne aussi pour ces deux nouvelles classes.
Question n°7 (A faire en dehors du TD)
Ecrire une version générique du quicksort fonctionnant sur les objets dérivant de Base.