Département de Mathématiques et Informatique
Module : Programmation Orientée Objet C++
Génie Informatique 1
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 ;
}
Void identifie(){
Pr. RAGRAGUI Anouar 1
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 : 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.
Exercice 4 : 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 ;
} ;
Pr. RAGRAGUI Anouar 2
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
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.
Pr. RAGRAGUI Anouar 3
