Vous êtes sur la page 1sur 4

D

epartement dInformatique
Facult
e des Sciences, Universit
e Ibn Zohr
Agadir
Correction
TD-3, C++, SMI5
Exercice 1 :
Donner la sortie du programme C++ suivant. Preciser le nombre dobjets crees et celui
dobjets detruits.
++
++
++
++
++
++
++
------

point par defaut


point normal
point clonage
point par defaut
point normal
point normal
droite normal
droite
point
point
point
point

Le nombre dobjets crees est : 7


Le nombre dobjets detruits est : 5
Il faut rajouter `a la fin du programme les deux instructions suivantes
delete d; et delete e;
afin quon puisse detruire les objets dynamiques d et e.
Exercice 2 :
Soit une classe vecteur3d definie comme suit:
class vecteur3d
{
float x,y,z;
public:
vecteur3d(float c1=0.0, float c2=0.0, float c3=0.0)
{x=c1; y=c2; z=c3;}
....
};
1. La fonction coincide
(a) La declaration
int coincide(vecteur3d); Sa definition:
int vecteur3d::vecteur3d(vecteur3d v)
{ if ((v.x==x) && (v.y == y) && (v.z == z)) return 1; else return 0;}
Lappel de la fonction : v1.coincide(v2);
(b) La declaration : int coincide(vecteur3d *); Sa definition:
int vecteur3d::vecteur3d(vecteur3d *adv)
{ if ((adv->x==x) && (adv->y == y) && (adv->z == z)) return 1; else return 0;}

Lappel de la fonction : v1->coincide(v2);


(c) La declaration : int coincide(vecteur3d &); Sa definition:
int vecteur3d::vecteur3d(vecteur3d v)
{ if ((v.x==x) && (v.y == y) && (v.z == z)) return 1; else return 0;}
Lappel de la fonction : v1.coincide(v2);
2. La fonction normax
(a) vecteur3d vecteur3d::normax(vecteur3d v)
{
float norm1 = x*x + y*y + z*z;
float norm2 = v.x*v.x + v.y*v.y + v.z*v.z;
if (norm1<norm2) return *this; else return v;
}
Supposons que v1,v2 et v3 sont 3 vecteurs, lappel seffectue comme suit:
v3 = v1.normax(v2);
(b) vecteur3d & vecteur3d::normax(vecteur3d & v)
{
float norm1 = x*x + y*y + z*z;
float norm2 = v.x*v.x + v.y*v.y + v.z*v.z;
if (norm1<norm2) return *this; else return v;
}
lappel seffectue comme suit: v3 = v1.normax(v2);
(c) vecteur3d *vecteur3d::normax(vecteur3d *v)
{
float norm1 = x*x + y*y + z*z;
float norm2 = v->x*v.x + v->y*v.y + v->z*v.z;
if (norm1<norm2) return this; else return v;
}
lappel seffectue comme suit: v3 = *(v1.normax(&v2));
3. Constructeur de recopie:
vecteur3d::vecteur3d(vecteur3d & v)
{
x=v.x; y=v.y; z=v.z;
}
4. Surcharge de + par une fonction memebre:
vecteur3d::operator+(vecteur3d & v)
{
return vecteur3d(x+v.x,y+v.y,z+v.z);
}
On peut utiliser une fonction non membre (friend).
5. surcharge de >> (fonction amie)

istream & vecteur3d::operator>>(istream & i, vecteur3d & v)


{
i>>x>>y>>z;
return i;
}
6. Surcharge de loperateur << (fonction amie)
ostream & vecteur3d::operator<<(ostream & o, vecteur3d & v)
{
o<<x<<"
"<<y<<"
"<<z;
return o;
}
7. On rajoute a` la classe vecteur3d une variable static (nbre) et une fonction
static (nombre). La variable nbre doit etre intialisee dans le fichier (.cpp) contenant limplementation des fonction membre : veteur3d::nbre = 0; La valeur
de nbre sera incrementee dans les constructeurs et decrementee dans les destructeurs (mise a` jour des construvcteurs). La fonction sera definie comme suit:
int vecteur3d::nombre(){return nbre;}

Exercice 3 :

#include<iostream.h> const int MAX = 20;


class ensemble_entiers{
int dim;
int *adr;
int nelem;
static int nbobjets;
public:
ensemble_entiers(int n=MAX){
adr=new int[dim=n];
nelem=0;
nbobjets++;
}
ensemble_entiers(ensemble_entiers & p){
adr=new int [dim=p.dim];
nelem=p.nelem;
int i;
for(i=0;i<nelem;i++) adr[i] = p.adr[i];
nbobjets++;
}
~ensemble_entiers(){delete [] adr; nbobjets--;}
void empile(int p){
if (nelem < dim) adr[nelem++] = p;
}
int depile(){if (nelem > 0) return adr[--nelem];
else return 0;

}
int pleine(){return (nelem==dim);}
int vide(){return (nelem == 0);}
int appartient(int p){
int i; int t=0;
for (i=0;i<nelem;i++)
if (adr[i]==p) {t=1;break;}
return t;
}
friend void operator<(ensemble_entiers &, int);
friend void operator>(ensemble_entiers &, int &);
friend ensemble_entiers operator+(ensemble_entiers,ensemble_entiers);
static int nbre_objets(){ return nbobjets;}
};
int ensemble_entiers::nbobjets=0; void operator<(ensemble_entiers
& p, int n){
if (p.nelem<p.dim)
p.adr[p.nelem++]=n;
}
void operator>(ensemble_entiers & p, int & n){
if (p.nelem>0) n=p.adr[--p.nelem];
}
ensemble_entiers operator+(ensemble_entiers p,ensemble_entiers q){
int i; ensemble_entiers r(p.dim+q.dim); r.nelem=p.nelem+q.nelem;
for(i=0;i<r.nelem;i++) if (i<p.nelem) r.adr[i]=p.adr[i]; else
r.adr[i]=q.adr[i-p.nelem]; return r; }
main(){
ensemble_entiers t(20);
int val,i;
for(i=0;i<20;i++)
{
cin>>val;
t.empile(val);
}
}