Vous êtes sur la page 1sur 5

Université Mohammed Premier Année universitaire 2014/2015

Faculté des Sciences d’Oujda Filière SMA (Semestre 5)


Dépt de Maths et Info. Module : POO : Langage C++

Correction d’Examen du Module POO : C++


Session Ordinaire
Exercice 1 : (8 pts)
Écrire les résultats de ce programme. Chaque résultat doit être justifié.
#include <iostream>
using namespace std ;
#define cube(x) x*x*x
Inline int CUBE(int X) { return X*X*X ; }
main() {
int a = 1 ;
int b = cube(a) ;
int c = cube(a++);
int f = cube(++a);
cout <<"a ="<< a <<" b="<< b <<" c="<< c << " f="<< f <<endl ;

int D = 2 ;
int E = CUBE(D);
int H = CUBE(D++);
int K = CUBE(++D);
cout <<"D ="<< D <<" E="<< E <<" H="<< H << " K="<< K <<endl ;

system("pause");
}

Réponse 1 :

a=1
b = a * a * a = 1  b =1 et a = 1
c = (a++ * a++) * a++ = (1 * 1)* 1 = 1  c =1 et a = 4
f = (++a * ++a) * ++a = (6 * 6) * 7 = 252  f = 252 et a = 7
D=2
E = CUBE(2) = (2 * 2)* 2 = 8  E = 8 et D = 2
H = CUBE(D++) = (2 * 2)* 2 = 8  H = 8 et D = 3
K =CUBE(++D) = (4 * 4)* 4 = 64  K = 64 et D = 4

Page1/5
Exercice 2 : (12 pts)
Écrire un programme qui permet de :
1/ Créer une classe de base nommée Vehicule. Un Vehicule possède trois membres
protégés :
 Annee_achat de type int ;
 prix_achat et prix_courant de type double ;
Et les méthodes publiques :
 affiche() permet d’afficher les trois membres : Annee_achat, prix_achat et
prix_courant ;
 calculePrix() permet de calculer le membre prix_courant d’un Vehicule à l’aide de
la formule suivante : prix_courant = (1.0 – ( (2015 - Annee_achat) * .01 ) * prix_achat ;
 Vehicule(int Annee, double prix) qui joue le rôle du constructeur de la classe en
question.

2/ Réaliser ensuite une classe nommée Camion dérivée publiquement de la classe Vehicule.
Cette classe fille comprend le membre protégé :
 Volume de type int ;
Et les méthodes publiques :
 affiche() afin que l’affichage donne également le membre Volume ;
 calculePrix() permet de calculer le membre prix_courant d’un Camion à l’aide de la
formule suivante : prix_courant = ( 1 – ( 0.1 * Volume / 1000 ) ) * prix_achat ;
 Camion(int Annee, double prix,int Vol) qui joue le rôle du constructeur de la classe
en question.

3/ De plus, définir une classe nommée Voiture dérivée publiquement de la classe mère
Vehicule. Cette sous classe de sa part contient trois membres protégés :
 nombre_portes de type int ;
 puissance et kilometrage de type double.
Elle va également redéfinir les méthodes suivantes :
 affiche() afin que l’affichage donne également les trois membres nombre_portes,
puissance et kilometrage;
 calculePrix() permet de calculer le membre prix_courant d’une Voiture à l’aide de
la formule suivante :
prix_courant = (1 - [ (2015 - Annee_achat) * 0.02 + 0.05 * kilometrage / 10000]) *
prix_achat;
 Voiture (int Annee, double prix, int portes, double cv, double km) qui joue le rôle du
constructeur de la classe en question.

4/ Enfin, écrire le programme principal qui permet d’appeler


 Un objet de type Vehicule

Page2/5
 Deux objets de type Voiture
 Trois objets de type Camion
Pour chaque objet, le programme principal va appliquer les méthodes affiche() et
calculePrix() .

Réponse 2 :
#include <iostream>
#include <vector>
using namespace std;

// ============================== Vehicules ==================================


class Vehicule {
public: Vehicule(int Annee, double prix){
Annee_achat = Annee ;
prix_achat = prix ;
prix_courant = prix ;
}
void affiche();
void calculePrix();
protected:
int Annee_achat ;
double prix_achat ;
double prix_courant ;
};
// -----------------------------------------------------------------------------------------------------------------------
void Vehicule::affiche() {
cout <<"Annee d'achat : "<< Annee_achat<<", prix d'achat : "<< prix_achat
<< ", prix actuel : " << prix_courant << endl;
}
// -----------------------------------------------------------------------------------------------------------------------
void Vehicule::calculePrix() {
double decote = (2015 - Annee_achat) * .01;
prix_courant = (1.0 - decote) * prix_achat;
}
// ============================== Camions ===================================
class Camion : public Vehicule {
public: Camion(int Annee, double prix, int Vol);
void affiche();
void calculePrix();
protected: int Volume ;
};
Page3/5
// -----------------------------------------------------------------------------------------------------------------------
Camion::Camion(int Annee, double prix,int Vol) : Vehicule(Annee, prix) {
Volume = Vol ;
}
// -----------------------------------------------------------------------------------------------------------------------
void Camion::affiche() {
cout << " ---- Camion ----" << endl;
Vehicule::affiche();
cout << " Volume : " << Volume << endl;
}
// -----------------------------------------------------------------------------------------------------------------------
void Camion::calculePrix() {
double decote = 0.1 * Volume / 1000.0;
prix_courant = (1.0 - decote) * prix_achat;
}
// ================================ Voitures =================================
class Voiture : public Vehicule {
public: Voiture(int Annee, double prix,int portes, double cv, double km);
void affiche();
void calculePrix();
protected:
int nb_portes ;
double puissance ;
double kilometrage ;
};
// -----------------------------------------------------------------------------------------------------------------------
Voiture::Voiture(int Annee, double prix,int portes, double cv,double km) : Vehicule(Annee,
prix) {
nb_portes = portes ;
puissance = cv ;
kilometrage = km ;
}
// -----------------------------------------------------------------------------------------------------------------------
void Voiture::affiche() {
cout << " ---- Voiture ----" << endl;
Vehicule::affiche();
cout << nb_portes << " portes, " << puissance << " CV, " << kilometrage << " km." << endl;
}

Page4/5
// -----------------------------------------------------------------------------------------------------------------------
void Voiture::calculePrix() {
double decote = (2015 - Annee_achat) * .02;
decote += 0.05 * kilometrage / 10000;
prix_courant = (1.0 - decote) * prix_achat;
}
// ============================== main() =====================================
int main() {
Vehicule Vh1(2010 , 10000.00);
Vh1.calculePrix() ; Vh1.affiche() ;
Voiture V1(2008, 147325.79, 5, 180.0,12000);
V1.calculePrix() ; V1.affiche();
Voiture V2(1995, 250000.00, 2, 280.0,81320);
V2.calculePrix() ; V2.affiche() ;
Voiture V3(2011, 7327.30, 3, 65.0,3000);
V3.calculePrix() ; V3.affiche();
Camion C1(1982, 1230673.90,250);
C1.calculePrix() ; C1.affiche();
Camion C2(2002, 4321098.00,1300);
C2.calculePrix() ; C2.affiche();
system("pause");
return 0;
}

Page5/5