Département de Mathématiques et Informatique
Module : Programmation Orientée Objet C++
Master Cryptologie et Sécurité Informatique
Année universitaire : 2023/2024
TD No4
Héritage simple, Héritage multiple et fonctions virtuelles
Exercice 1 : Héritage simple
Soit la classe suivante :
class Individu{
protected :
int age ;
string nom ;
string prenom ;
public :
Individu(string nom= ““, string prenom=““, int age=0);
Individu(const Individu &); // constructeur de recopie
string getNom() ; // retourne le nom ;
string getPrenom() ;//retourne le prénom
int getAge() ;// retourne l’âge
} ;
1. Définissez les méthodes de la classe Individu et testez-la en créant plusieurs instances.
2. Proposez en suite une classe dérivée avec un mode de dérivation “public“ de la classe Individu. Appelez cette
nouvelle classe Etudiant et complétez-la de manière à :
Déclarer deux données privées pour cette classe, qui correspondent au niveau et la filière,
Définir le constructeur traitant 5 paramètres,
Définir le constructeur de recopie,
Surdéfinir la fonction affiche pour cette classe,
3. Tester plusieurs instances de cette classe.
Exercice 2 : Héritage simple et fonctions virtuelles
On considère la classe Point suivante permettant de définir des points à deux coordonnées cartésiennes :
class Point{
int x ;
int y ;
public :
Point(int abs, int ord){
x=abs ;
y=ord ;
}
Pr. Mohamed CHERRADI
1
Void identifie(){
cout<< “ Je suis un point “ ;
}
Void affiche(){
identifie() ;
cout<< “ coordonnées : “<<x<< “ “<<y ;
}
} ;
1) Créer une classe PointCol, dérivée de la classe Point, comportant :
Un membre donnée supplémentaire coul de type int, pour représenter la couleur d’un point.
Un constructeur permettant de définir la couleur d’un objet de type PointCol;
2) Redéfinir la méthode identifie() pour afficher la couleur d’un point coloré.
3) Adapter la classe Point pour pouvoir utiliser correctement la fonction membre affiche de la classe
Point pour un objet de type PointCol.
4) Ajouter une fonction membre rho, dans la classe PointCol, fournissant la première coordonnée
polaire (racine carrée(x2+y2)) d’un point coloré :
a) En ajoutant des fonctions membres appropriées dans la classe de base Point;
b) En supposant que les membres x et y ont déclarés protégés (protected) dans la classe de base
Point et non plus privés.
Exercice 3 : Héritage multiple
On veut créer une classe liste permettant de manipuler des listes chaînées dans lesquelles le type de l’information
(associée à chaque nœud ) n’est pas connu par la classe. Soit la déclaration suivante :
struct element{
void*contenu ;
element*suivant ;
} ;
class liste{
element*debut ; // pointeur sur le premier nœud de la liste
element*courant ; //pointeur sur le nœud courant
public :
liste(); //constructeur initialisant une liste créée à vide
~liste(); // dustructeur ;
void ajouter(void*); //ajouter un élément dans la liste
liste& operator=(liste&) ;// opérateur d’affectation
bool empty() ; // qui permet de connaître si la liste est
// vide ou non.
int getSize() ; // retourne le cardinal de la liste
void* premier() ; // fournit l’information associée au
//premier nœud de la liste
Pr. Mohamed CHERRADI
2
void*prochain() ; // fournit l’information associée au
// prochain nœud
int fini() ; // qui permet de savoir si la fin de la liste
// est atteinte ou non
} ;
1) Compléter la déclaration de la classe liste.
2) En utilisant la classe Point de l’exercice 2, créer une classe listePoints, dérivée à la fois de
liste et de Point, pour qu’elle puisse permettre de manipuler des listes chaînées de points, c-à-d
une liste dans laquelle l’information associée à chaque nœud est de type Point. La classe
listePoints comporte un constructeur et redéfinit la fonction d’affichage pour afficher tous les
points d’une liste de points.
Donner la définition de la classe listePoints, puis écrire un programme qui effectue les opérations
suivantes :
Création et affichage de trois points p1(1,2), p2(0,1) et p3(2,2) ;
Création d’une liste de points l,
Insertion de p1, p2 et p3 dans la liste l,
Affichage de la liste l et de son cardinal.
Exercice 4 : Classe abstraite
Supposons que vous ayez une classe de base appelée "Shape" et deux classes dérivées appelées "Circle" et
"Rectangle". La classe "Shape" a une fonction virtuelle pure appelée "calculateArea()" qui calcule l'aire de la
forme, tandis que les classes dérivées implémentent cette fonction en fonction de leur propre géométrie.
Votre tâche consiste à créer un programme qui définit un tableau de pointeurs de formes (Shape*) et qui les
initialise avec des cercles et des rectangles. Ensuite, le programme doit boucler à travers le tableau et afficher
l'aire de chaque forme.
1. Créez la classe "Shape" avec la fonction virtuelle pure "calculateArea()".
2. Créez les classes "Circle" et "Rectangle" dérivées de la classe "Shape". Implémentez la fonction
"calculateArea()" pour chaque classe.
3. Dans le programme principal, créez un tableau de pointeurs de formes (Shape*). Initialisez-le avec des
cercles et des rectangles.
4. Bouclez à travers le tableau et appelez la fonction "calculateArea()" pour chaque forme. Affichez l'aire
de chaque forme.
Pr. Mohamed CHERRADI
3
Exercice 5 :
Le but de cet exercice est de construire des tableaux de réels flottants dont les valeurs se trouvent dans un intervalle
donné.
1. Implémenter une classe Tableau, où la taille du tableau sera un membre donné. La classe contiendra :
• U n constructeur prenant un entier en paramètre, quiallouera dynamiquement la
mémoire pour un tableau de la taille de l’entier ;
• U n destructeur quilibérera la mémoire ;
• U n constructeur de recopie ;
• L’opérateur d’affectation = redéfini.
• Elle surdéfinira également l’opérateur [] pour qu’ilpermette d’accéder aux
éléments du tableau par référence, et ainsiautoriser la modification de ces
éléments.
2. Implémenter une classe TableauBorne dérivée de la classe Tableau. En plus des membres donnés de
la classe Tableau (quidevront être accessibles dans la classe TableauBorne), cette
classe comportera deux membres donnés de type float correspondant aux bornes de
l’intervalle dans lequeldevront se trouver les éléments du tableau. O n définira donc un
constructeur pour cette classe prenant un entier et deux flottants en arguments.
3. Dans la classe TableauBorne, surdéfinir l’opérateur [] pour que la modification des valeurs du tableau ne
soit plus autorisée via cet opérateur. L’opérateur [] de la classe Tableau ne devra pas être accessible pour un
utilisateur de la classe TableauBorne.
Pr. Mohamed CHERRADI
4
