UNIVERSITE DE LA MANOUBA -----¤¤¤¤----- ECOLE NATIONALE DES SCIENCES DE L'INFORMATIQUE
ANNEE UNIVERSITAIRE 2011-2012
Devoir surveillé
Matière : Programmation Orientée Objets Niveau : II1 Enseignants : K. BEN RHOUMA, A. BEN HASSINE, W. CHAKER, O. FAKHFAKH, I. FLISS, S. MTIBAA Barème : 3+ 7 + 10
Date : 17 mars 2012 Durée: 2H Documents : non autorisés Nb pages : 8
Nom & Prénom :................................................................................. Groupe :......................
Il sera tenu compte de la présentation et de la clarté de vos réponses
Exercice n°1
Donnez un tableau indiquant la valeur des variables g1, ptr, ptr1, et a après chacune des instructions numérotées de 1 à 6. int g1=2; int *ptr;
int *& f3(int x) {
int *& f3(int x=7);
int *f1(int &x) { int res=++x; return (&res); } int &f2(int *p) { p=&g1; (*p)++; return *f3(); }
x++; (*ptr)+=x; return ptr; }
void main() { 1. ptr=&g1; 2. int &a=*ptr; 3. int *ptr1=f1(a); 4. *ptr1=f2(ptr); 5. (*ptr1)++; 6. a++; }
1/6
Exercice n°2
Soit les deux classes A et B suivantes :
class A { int att;
public : A () { att = 0; cout << "A::A()" << endl; }
Publicité
A (int n) { att = n; cout << "A::A(int) avec n=" << n << endl; }
A (const A& a) { att = a.att; cout << "A::A(A&)" << att << endl; }
class B { A ab; int * i ;
public: B() { i= new int; cout << "B::B()" << endl; }
B(int a) { cout << "B::B(" << a << ")" << endl; i= new int; ab = a; }
B (A& t) : ab(t) { cout << "B::B(A&) avec t" << endl; }
void operator= (const A& a) { att = a.att; cout << "affectation d'un A avec " << att << endl; }
A::~A() { cout << "A::~A()" << endl; }
void afficher() const { cout << "A::afficher(" << att << ")" << endl; } };
~B() { cout << "B::~B()" << endl; delete i; }
A get_att() const { return ab; }
void afficher() const { cout << "B::afficher()" << endl; A a; a.afficher(); }
};
Pour chacune des instructions suivantes appartenant à un même bloc, donnez s’il y a lieu : l’affichage produit et éventuellement la ou les erreurs dans la gestion de la mémoire (violation et/ou fuite) en expliquant les causes. A a1; A a2(1); A a3=a1; a1=a2; B b1(2); b1.afficher(); b1.get_att().afficher(); B *b2; b2->afficher(); b2= new B(5); *b2=a3 ;
2/6
b1=*b2 ; B b3 = b1 ; Fin du bloc
Exercice n°3 :
L’objectif de cet exercice est de définir en C++ une manière d’évaluer une expression. Une expression est une suite de variables combinées par un ensemble d'opérateurs. Exemple E= A+B*C ; Pour éviter les parenthèses et garantir une écriture non ambiguë et une évaluation facile, nous nous basons sur des expressions post fixées. Dans ces expressions, l’ordre des priorités des opérateurs est déterminé par la position des opérateurs dans les expressions. Donc, on n’aura pas à chercher la priorité entre les opérateurs. Dans les expressions post fixées l’opérateur est placé après les opérandes. Dans ce cas E devient E= ABC * +. Ces expressions peuvent être facilement évaluées en utilisant les piles. Nous considérons dans le cadre de ce problème que les opérandes de l’expression à évaluer sont des polynômes.
Nous nous proposons donc, de considérer le programme principal suivant : int main () { Polynome A(2), B(4), C(3), Poly_res ; A.initialiser() ; B.initialier() ; C.initialiser() ; Expression E; E= ABC *+ ; Poly_res= E.evaluer_poly() ; //affichage du polynôme résultat Return 0 ; } Première partie :
Publicité
Nous proposons en premier lieu de définir une classe ‘Polynome’ permettant de manipuler (addition, multiplication, soustraction, …) les polynômes à une variable et à coefficients entiers caractérisé par un tableau dynamique de coefficients entiers tab et un degré N (entier) : Un polynôme a une variable est de la forme : A= a0*x^0+a1*x^1+a2*x^2+...+aN*x^N avec N≥0 aN≠0 où les ai sont les coefficients du polynôme. Pour simplifier, on définira seulement les opérations sur les polynômes qui sont utiles pour l’évaluation de l’expression, c’est-à-dire additionner deux polynômes, multiplier deux polynômes, soustraire deux polynômes. On se propose de définir toutes ces opérations uniquement par des opérateurs (+, *, -). Rappelons que pour A= 5*x^0-3*x^1+ 1*x^2 et B= 0*x^0-2*x^1+ 4*x^2 A+B=5*x^0-5*x^1+ 5*x^2 A-B=5*x^0-1*x^1-3*x^2 A*B=0*x^0-10*x^1+ 26*x^2- 14*x^3+4*x^4
Travail à faire Donnez la déclaration et l’implémentation de la classe ‘Polynome’. Il s’agit de :
1) Définir les attributs nécessaires de la classe ‘Polynome’.
2) Donner le corps du constructeur ayant un argument N (degré du polynôme et qui par défaut est
égal à 0).
3/6
3) Nous proposons d’ajouter une méthode d’initialisation ‘init’ du polynôme. Cette méthode
permet à l’utilisateur de saisir au clavier le degré du polynôme et ses coefficients. Donnez la déclaration + le corps de la méthode ‘init’.
4) Pensez-vous qu’il est utile de définir un destructeur ? Dans l’affirmative, donnez son corps.
5) Donnez les déclarations et les implémentations de toutes les opérations de manipulation de polynôme. Notez que toutes ces opérations doivent être définies uniquement par des opérateurs (+, *, -).
4/6
Nom & Prénom :.......................................................................... Groupe :......................
6) Pour l’affichage d’un polynôme de degré N, il s’agit de l’afficher sous la forme a0*x^0+a1*x^1+a2*x^2+...+aN*x^N. Par exemple pour un polynôme P de degré 3, avec tab= {1, 2, 1, 3}, l’affichage sera : 1* x^0+ 2* x^1+1* x^2+3* x^3.
Donnez la définition et l’implémentation d’une méthode ou d’une fonction permettant l’affichage d’un polynôme (vous pouvez choisir entre la définition d’une méthode affichage ou bien la surcharge de l’opérateur << permettant l’affichage d’un polynôme par le biais de flux d'E/S (iostream).)
Deuxième partie : Nous nous proposons maintenant de définir une classe ‘Expression’ représentant les expressions post fixées. Dans ce problème, une expression post fixée est formé d’un ensemble d’opérandes polynomiales suivi d’un ensemble d’opérateurs (+, *, -). Les opérandes de l’expression sont stockés dans une pile de polynômes et ses opérateurs sont stockés dans une pile d’opérateurs. Pour cela nous nous basons sur les définitions des classes Pile_oper (Pile d’opérateurs considérés comme des caractères), Pile_poly (Pile de polynômes) suivantes : Class Pile_oper { public:
Pile_poly { public:
Pile_oper (); ~Pile_oper ();
~ Pile_poly ();
Pile_poly ();
Publicité
void empiler(char); char depiler(); bool estVide(); char getSommet(); int size();
char *tab; int taille;
private:
void empiler(Polynome); Polynome depiler(); bool estVide(); Polynome getSommet(); int size();
private: Polynome *tab; int taille; int indice; } ;
int indice; } ; Pour simplifier, on se contentera de définir les opérations de base sur les expressions à savoir la construction et la destruction en plus des opérations d’affectation d’expression et d’évaluation des expressions. L’affectation d’une expression revient à parcourir l’expression affectée (source) de gauche à droite et de :
• Empiler les opérandes que l'on rencontre dans la pile des polynômes de l’expression
destination.
• Empiler les opérateurs que l'on rencontre dans la pile des opérateurs de l’expression
destination.
L’évaluation d’une expression est donnée grâce à la méthode evaluer_poly() qui permet d’évaluer une expression et retourne un polynôme résultat suivant , il s’agit de :
• Dépiler un opérateur de la pile des opérateurs • Lorsque l'on rencontre un opérateur binaire (+, *, -), il faut: • Dépiler les deux derniers polynômes stockés dans la pile des polynômes • Appliquer l’opérateur sur les polynômes dépilés • Empiler le résultat dans la pile des polynômes • Continuer le dépilement de la pile des opérateurs et l’application de l’opérateur, une fois la pile
des opérateurs est vide, le polynôme résultat devrait être dépilé et affiché.
Travail à faire
7) Donnez la déclaration (fichier d’entête .h) de la classe ‘Expression’.
5/6
8) Donnez l’implémentation de cette classe (le fichier .cpp).
6/6