USTHB/FEI/Département de Télécommunications /Master RT 19-01-2019

‫جامعة هواري بومدين للعلوم والتكنولوجيا‬

Université des Sciences et de la Technologie Houari Boumediene

Faculté d’Electronique et d’Informatique

Département de Télécommunications

Programmation Orientée Objets en C++

Examen Final (Durée 1h30)

Nom : Note :

Prénom : /20

Matricule :

***************************************************************************************

Exercice 1: (4 points)

1. Ecrire un programme qui remplit un vector « Tab1 » de type entier en utilisant les instructions cin et
push-back. L’insertion s’arrête lorsque l’utilisateur introduit une valeur d’un autre type.
2. Déclarer 2 itérateurs « i » et « j » tels que : « i » est initialisé par l’adresse du premier élément de Tab1 et
« j » initialisé par l’adresse du dernier élément. A l’aide d’une boucle for, écrire une procédure qui
permet de comparer le premier et le dernier élément de Tab1 et met le plus grand dans un vector
« Tab2 ». Incrémenter i et décrémenter j et continuer la procédure tant que i est différent de j. Afficher
les éléments de Tab2.

// Code Main :

…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
1
USTHB/FEI/Département de Télécommunications /Master RT 19-01-2019

…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………

Exercice 2 : (6 points)

Dans cet exercice, on souhaite créer un programme qui effectue quelques traitements sur une image couleur.
Pour cela, On doit créer une classe image contenant les attributs suivants : n et m de type int désignant le
nombre de lignes et de colonnes de l’image. Un pointeur sur une matrice mat de type int. Le constructeur
utilisé comporte des arguments pour initialiser n et m. Il effectue aussi, une initialisation de la matrice par
des valeurs aléatoires dans l’intervalle [0 , 255].

// Classe image :

………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………….................................................…
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………….....................................................

2
USTHB/FEI/Département de Télécommunications /Master RT 19-01-2019

2. Définir une classe traitement contenant trois fonctions pour manipuler les attributs de la classe image.
Comment doit-on déclarer cette classe pour pouvoir appliquer ses fonctions ?

……………………………………………………………………………………………………………….......

3. Pour créer l’image en niveau de gris, on définit une fonction « NGris » qui reçoit en argument des
pointeurs sur trois objets de la classe image (R, G et B). Cette fonction renvoie un objet image qui
contient une représentation en niveau de gris (Chaque élément de la matrice mat de l’objet renvoyé
correspond à la moyenne des attributs mat des 3 objets R, G, et B pris à la même position).

// Code : classe traitement +la fonction NGris

………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………
……….

4. Rajouter une fonction « Norma » avec un argument objet image. La fonction effectue une normalisation
de la matrice mat de l’argument en divisant tous les éléments par la valeur maximale de cette matrice. Le
programme recherche d’abord le maximum et ensuite, effectue la normalisation. On met le résultat dans
une matrice Rmat de type float déclarée par allocation dynamique.

// Code Fonction Norma :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
3
USTHB/FEI/Département de Télécommunications /Master RT 19-01-2019

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….

5. Ecrire le code d’une fonction affiche membre de la classe traitement sans valeur de retour. Cette
fonction reçoit un objet image en argument et affiche ses attributs.

// Code de la fonction affiche :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….

6. Dans main, créer des objets image avec n=m=10. Créer un objet traitement et effectuer l’appel de la
fonction NGris. Appeler Norma et Affiche pour l’objet retourné par NGris.

// Code main :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
4
USTHB/FEI/Département de Télécommunications /Master RT 19-01-2019

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….…
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….

Exercice 3 : (6 points)

1. Pour automatiser la gestion des salaires des employés d’une usine, on demande de réaliser le programme
suivant : Définir une classe de base Employé avec les attributs suivants: Nom (string), code (int),
Point_indiciel Pin (int). Un constructeur pour initialiser les attributs (on donne une valeur par défaut à Pin
égale à 500). Rajouter trois fonctions telles que :
 Une fonction calcul-prime (bool a) qui calcule et renvoie la prime d’un employé selon la valeur de a. Si
a est true, la prime prend Pin*2, sinon elle prend Pin*0.5.
 Une fonction salaire qui renvoie le salaire de l’employé « float salaire(float prime) ». Cette fonction
reçoit la prime comme argument et calcule le salaire en considérant la multiplication Pin*prime.
 Une fonction affiche sans valeur de retour qui reçoit la prime comme argument. Cette fonction affiche les
attributs, le salaire (La valeur retournée par la fonction salaire), et le statut de l’employé « employé ».

N.B : Les fonctions salaire et affiche seront surchargées par les classes dérivées.

// Code de la classe Employé :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….…
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….…
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..

2. Définir une classe Ingénieur qui dérive de Employé. On utilise un constructeur pour initialiser les
attributs hérités. Cette classe contient une surcharge de salaire qui multiplie le Pin par 4 avant de calculer

5
USTHB/FEI/Département de Télécommunications /Master RT 19-01-2019

le salaire par Pin*prime. On rajoute une surcharge de la fonction affiche dans laquelle le statut affiché est
« Ingénieur ».

// Code de la classe Ingénieur :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….…
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..

3. Définir une classe Technicien qui dérive de Employé, avec les mêmes fonctions que Ingénieur sauf que
pour le salaire on multiplie le Pin par 2*prime. Aussi, on affiche le statut « Technicien » dans la fonction
affiche.

// Code de la classe Technicien :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….…
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………

6
USTHB/FEI/Département de Télécommunications /Master RT 19-01-2019

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..

4. Définir une classe Stagiaire qui dérive de Employé, et prend les fonctions de la classe de base. Donc, on
demande de mettre un constructeur qui initialise uniquement le code et le nom (On prend la valeur par
défaut pour le Pin).

// Code de la classe Stagiaire :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..

5. Dans main, créer un tableau dynamique contenant 3 objets de type Employé. Le premier élément est un
objet Ingénieur, le deuxième et un objet Stagiaire et le troisième est un objet Technicien. Pour chaque
objet, appeler la fonction « calcul_prime » et sauvegarder le résultat dans un tableau. En respectant la
condition de polymorphisme, on demande d’effectuer un appel simultané des fonctions salaire et affiche
pour tous les objets en utilisant les valeurs sauvegardées des primes.

// Code main :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..

7
USTHB/FEI/Département de Télécommunications /Master RT 19-01-2019

Exercice 4 : (4 points)

Considérons les templates de deux classes de formes géométriques Cylindre et Ellipse.

1. Définir un template d’une classe Cylindre ayant deux types symboliques T et U. La classe possède deux
attributs (Hauteur de type U et Rayon de type T). Déclarer un constructeur pour initialiser les attributs,
une fonction Volume qui renvoie le volume du cylindre de type U, calculé par « 3.14*
Rayon*Rayon*Hauteur ». Déclarer enfin, une méthode Message sans valeur de retour et ayant comme
argument un pointeur sur un objet de la classe ellipse (classe template). Cette fonction déclenche la
méthode Zoom de l’objet ellipse et met la valeur renvoyée dans Hauteur.

// Code classe Cylindre :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..

2. Ajouter le template de la classe Ellipse avec un seul type symbolique U. La classe possède deux attributs
R1 et R2 indiquant les axes de l’ellipse. Définir un constructeur pour initialiser les attributs, une fonction
surface qui retourne la surface de l’ellipse calculée par 3.14*R1*R2. Enfin, rajouter la fonction Zoom
qui double les valeurs des attributs et renvoie ensuite la somme R1+R2.

// Code de la classe Ellipse :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………..…
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….

8
USTHB/FEI/Département de Télécommunications /Master RT 19-01-2019

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………..…
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….…
………………………………………………………………………………………………………………………………………………………………..……
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..

3. Dans main, instancier les classes Cylindre et Ellipse avec des valeurs de votre choix. Pour apprécier
l’envoi de messages entre les classes, appeler la méthode Message de Cylindre et vérifier le volume avant et
après l’appel.

// Code main :

………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………..…
………………………………………………………………………………………………………………………………………………………………………
…………………………………………………………………………………………………………………………………………………………………….…
………………………………………………………………………………………………………………………………………………………………..……
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..
………………………………………………………………………………………………………………………………………………………………………
……………………………………………………………………………………………………………………………………………………………………..

Bon Courage