Universit AbdelMalek Essadi

Facult des Sciences et Techniques

Dpartement Gnie Informatique
Tanger

Anne Universitaire : 2012/2013

Concepts de Base de POO & C++
(Filire: LST-GI/S5)
Prof. E. M. EN-NAIMI

Sries de TPs N : (7, 8 & 9)

Exercice 1:

i)
ii)

On dispose dun fichier nomm point.h contenant la dclaration suivante de la classe point :
class point
{ float x, y ;
public :
void initialise (float abs=0.0, float ord=0.0)
{ x = abs ; y = ord ;
}
void affiche ()
{ cout << "Point de coordonnes : " << x << " " << y << "\n" ;
}
float abs () { return x ; }
float ord () { return y ; }
};
Crer une classe point-B, drive de point comportant simplement une nouvelle fonction membre nomme rho,
fournissant la valeur du rayon vecteur (premire coordonne polaire) dun point.
Mme question, en supposant que les membres x et y ont t dclars protgs (protected) dans point, et non plus privs.

iii) Introduire un constructeur dans la classe point-B.

iv) Quelles sont les fonctions membre utilisables pour un objet de type point-B ?

Exercice 2:
1) On dispose dun fichier point.h contenant la dclaration suivante de la classe point :

i)

ii)
2)

#include <iostream>
using namespace std ;
class point
{ float x, y ;
public :
point (float abs=0.0, float ord=0.0)
{ x = abs ; y = ord ;
}
void affiche ()
{ cout << "Coordonnes : " << x << " " << y << "\n" ;
}
void deplace (float dx, float dy)
{ x = x + dx ; y = y + dy ;
}
};
Crer une classe pointcol, drive de point, comportant :
un membre donne supplmentaire cl, de type int, contenant la couleur dun point ;
les fonctions membre suivantes :
affiche (redfinie), qui affiche les coordonnes et la couleur dun objet de type pointcol ;
colore (int couleur), qui permet de dfinir la couleur dun objet de type pointcol,
un constructeur permettant de dfinir la couleur et les coordonnes (on ne le dfinira pas en ligne).
Que fera alors prcisment cette instruction : pointcol (12.5, 0.25, 10) ;
On suppose quon dispose de la mme classe point (et donc du fichier point.h) que dans lexercice (1) prcdent.
Crer une classe pointcol possdant les mmes caractristiques que ci-dessus, mais sans faire appel lhritage ?
Quelles diffrences apparatront entre cette classe pointcol et celle de lexercice (1) prcdent, au niveau des
possibilits dutilisation ?

Exercice 3:
Soit une classe point ainsi dfinie (nous ne fournissons pas la dfinition de son constructeur) :
class point
{ int x, y ;
public :
point (int = 0, int = 0) ;
friend int operator = = (point, point) ;
};
int operator = = (point a, point b)
{ return a.x = = b.x && a.y = = b.y ;
}
Soit la classe pointcol, drive de point :
class pointcol : public point
{ int cl ;
public :
pointcol (int = 0, int = 0, int = 0) ; // ventuelles fonctions membre
};
i)

Si a et b sont de type pointcol et p de type point, les instructions suivantes sont-elles correctes et, si oui, que font-elles ?

if (a = = b) ... // instruction 1
if (a = = p) ... // instruction 2
if (p = = a) ... // instruction 3
if (a = = 5) ... // instruction 4
if (5 = = a) ... // instruction 5
ii)

Mmes questions, en supposant, cette fois, que loprateur + a t dfini au sein de point, sous forme dune fonction membre.

Exercice 4 (Facultatif):
1)

Soit une classe vect permettant de manipuler des vecteurs dynamiques dentiers (cest--dire dont la dimension
peut tre fixe au moment de lexcution) dont la dclaration (fournie dans le fichier vect.h) se prsente ainsi :
class vect
{ int nelem ; // nombre d'lments
int * adr ; // adresse zone dynamique contenant les lments
public :
vect (int) ; // constructeur (prcise la taille du vecteur)
~vect () ;
// destructeur
int & operator [] (int) ; // accs un lment par son "indice"
};
On suppose que le constructeur alloue effectivement lemplacement ncessaire pour le nombre dentiers reu en
argument et que loprateur [ ] peut tre utilis indiffremment dans une expression ou gauche dune affectation.
Crer une classe vect-B, drive de vect, permettant de manipuler des vecteurs dynamiques, dans lesquels on peut
fixer les bornes des indices, lesquelles seront fournies au constructeur de vect-B. La classe vect apparatra ainsi comme un
cas particulier de vect-B (un objet de type vect tant un objet de type vect-B dans lequel la limite infrieure de lindice est 0).
On ne se proccupera pas, ici, des problmes ventuellement poss par la recopie ou laffectation dobjets de type vect-B.
2)

Soit une classe vect permettant de manipuler des vecteurs dynamiques dentiers, dont la dclaration (fournie dans
un fichier vect.h) se prsente ainsi (notez la prsence de membres protgs) :
class vect
{ protected :
// en prvision d'une ventuelle classe drive
int nelem ;
// nombre d'lments
int * adr ;
// adresse zone dynamique contenant les lments
public :
vect (int) ;
// constructeur
~vect () ;
// destructeur
int & operator [ ] (int) ; // accs un lment par son "indice"
};
On suppose que le constructeur alloue effectivement lemplacement ncessaire et que loprateur [ ] peut tre
utilis indiffremment dans une expression ou gauche dune affectation. En revanche, comme on peut le voir, cette classe
na pas prvu de constructeur par recopie et elle na pas sur-dfini loprateur daffectation. Laffectation et la transmission
par valeur dobjets de type vect posent donc les problmes habituels .
Crer une classe vect-C, drive de vect, telle que laffectation et la transmission par valeur dobjets de type vect-C
sy droulent convenablement. Pour faciliter lutilisation de cette nouvelle classe, introduire une fonction membre taille
fournissant la taille dun vecteur.
crire un petit programme de test (ou dessai) ?

Exercice 5:
1) Quels seront les rsultats fournis par ce programme :
#include <iostream>
using namespace std ;
class A
{ int n ;
float x ;
public :
A (int p = 2)
{n=p;x=1;
cout << "** construction objet A : " << n << " " << x << "\n" ;
}
};
class B
{ int n ;
float y ;
public :
B (float v = 0.0)
{n=1;y=v;
cout << "** construction objet B : " << n << " " << y << "\n" ;
}
};
class C : public B, public A
{ int n ;
int p ;
public :
C (int n1=1, int n2=2, int n3=3, float v=0.0) : A (n1), B(v)
{ n = n3 ; p = n1+n2 ;
cout << "** construction objet C : " << n << " " << p <<"\n" ;
}
};
int main()
{ C c1 ;
C c2 (10, 11, 12, 5.0) ;
}
2)

Mme question que prcdemment, en remplaant simplement len-tte du constructeur de C par :

3)

C (int n1=1, int n2=2, int n3=3, float v=0.0) : B(v)

Mme question que dans la question 1 ci-dessus, en supposant que len-tte du constructeur de C est la suivante :
C (int n1=1, int n2=2, int n3=3, float v=0.0)

Exercice 6:
1) Quels seront les rsultats fournis par ce programme :
#include <iostream>
using namespace std ;
class A
{ int na ;
public :
A (int nn=1)
{ na = nn ; cout << "$$construction objet A " << na << "\n" ;
}
};
class B : public A
{ float xb ;
public :
B (float xx=0.0)
{ xb = xx ; cout << "$$construction objet B " << xb << "\n" ;
}
};
class C : public A
{ int nc ;
public :
C (int nn= 2) : A (2*nn+1)
{ nc = nn ;
cout << "$$construction objet C " << nc << "\n" ;
}

};
class D : public B, public C
{ int nd ;
public :
D (int n1, int n2, float x) : C (n1), B (x)
{ nd = n2 ;
cout << "$$construction objet D " << nd << "\n" ;
}
};
int main()
{ D d (10, 20, 5.0) ;
}

2) Transformer le programme prcdent, de manire quun objet de type D ne contienne quune seule fois les
membres de A (qui se rduisent en fait lentier na). On sarrangera pour que le constructeur de A soit appel
avec la valeur 2*nn+1, dans laquelle nn dsigne largument du constructeur de C.

Exercice 7 (Facultatif):
On souhaite crer une classe liste permettant de manipuler des listes chanes dans lesquelles la nature de
linformation associe chaque noeud de la liste nest pas connue (par la classe). Une telle liste correspondra au
schma suivant :

La dclaration de la classe liste se prsentera ainsi :

struct element
// structure d'un lment de liste
{ element * suivant ;
// pointeur sur l'lment suivant
void * contenu ;
// pointeur sur un objet quelconque
};
class liste
{ element * debut ;
// pointeur sur premier lment
// autres membres donnes ventuels
public :
liste () ;
// constructeur
~liste () ;
// destructeur
void ajoute (void *) ;
// ajoute un lment en dbut de
liste
void * premier () ;
// positionne sur premier lment
void * prochain () ;
// positionne sur prochain lment
int fini () ;
};
La fonction ajoute devra ajouter, en dbut de liste, un lment pointant sur linformation dont ladresse est fournie en
argument (void *). Pour explorer la liste, on a prvu trois fonctions :

premier, qui fournira ladresse de linformation associe au premier noeud de la liste et qui, en mme temps,
prparera le processus de parcours de la liste ;

prochain, qui fournira ladresse de linformation associe au prochain noeud ; des appels successifs de
prochain devront permettre de parcourir la liste (sans quil soit ncessaire dappeler une autre fonction) ;

fini, qui permettra de savoir si la fin de liste est atteinte ou non.
i) Complter la dclaration prcdente de la classe liste et en fournir la dfinition de manire quelle fonctionne
comme demand.
ii) Soit la classe point suivante :
class point
{ int x, y ;
public :
point (int abs=0, int ord=0) { x=abs ; y=ord ; }
void affiche () { cout << "Coordonnes : " << x << " " << y << "\n" ; }
};

Crer une classe liste_points, drive la fois de liste et de point, pour quelle puisse permettre de manipuler des listes
chanes de points, cest--dire des listes comparables celles prsentes ci-dessus, et dans lesquelles linformation
associe est de type point. On devra pouvoir, notamment :

ajouter un point en dbut dune telle liste ;

disposer dune fonction membre affiche affichant les informations associes chacun des points de la liste de
points.
iii) crire un petit programme dessai.

Exercice 8:
Quels rsultats produira le programme suivant :
#include <iostream>
using namespace std ;
class point
{ protected : // pour que x et y soient accessibles pointcol
int x, y ;
public :
point (int abs=0, int ord=0) { x=abs ; y=ord ; }
virtual void affiche ()
{ cout << "Je suis un point \n" ;
cout << " mes coordonnes sont : " << x << " " << y << "\n" ;
}
};
class pointcol : public point
{ short couleur ;
public :
pointcol (int abs=0, int ord=0, short cl=1) : point (abs, ord)
{ couleur = cl ;
}
void affiche ()
{ cout << "Je suis un point color \n" ;
cout << " mes coordonnes sont : " << x << " " << y ;
cout << " et ma couleur est : " << couleur << "\n" ;
}
};
int main()
{
point p(3,5) ; point * adp = &p ;
pointcol pc (8,6,2) ; pointcol * adpc = &pc ;
adp->affiche () ; adpc->affiche () ; // instructions 1
cout << "-----------------\n" ;
adp = adpc ;
adp->affiche () ; adpc->affiche () ; // instructions 2
}

Exercice 9:
Quels rsultats produira le programme suivant :
#include <iostream>
using namespace std ;
class point
{ int x, y ;
public :
point (int abs=0, int ord=0) { x=abs ; y=ord ; }
virtual void identifie ()
{ cout << "Je suis un point \n" ;
}
void affiche ()
{ identifie () ;
cout << "Mes coordonnes sont : " << x << " " << y << "\n" ;
}
};
class pointcol : public point
{ short couleur ;

public :
pointcol (int abs=0, int ord=0, int cl=1 ) : point (abs, ord)
{ couleur = cl ; }
void identifie ()
{ cout << "Je suis un point color de couleur : " << couleur << "\n" ; }
};
int main()
{ point p(3,4) ;
pointcol pc(5,9,5) ;
p.affiche () ;
pc.affiche () ;
cout << "---------------\n" ;
point * adp = &p ;
pointcol * adpc = &pc ;
adp->affiche () ; adpc->affiche () ;
cout << "---------------\n" ;
adp = adpc ;
adp->affiche () ; adpc->affiche () ;
}

Exercice 10:
1) Crer un patron de fonctions permettant de calculer le carr dune valeur de type quelconque
(le rsultat possdera le mme type). crire un petit programme utilisant ce patron.
2) Crer un patron de fonctions permettant de calculer la somme dun tableau dlments de type quelconque, le
nombre dlments du tableau tant fourni en paramtre (on supposera que lenvironnement utilis accepte
les paramtres expression ). crire un petit programme utilisant ce patron.

Exercice 11:
Soit cette dfinition de patron de fonctions :
template <class T, class U> T fct (T a, U b, T c)
{ .....
}
Avec les dclarations suivantes :
int n, p, q ;
float x ;
char t[20] ;
char c ;
Quels sont les appels corrects et, dans ce cas, quels sont les prototypes des fonctions instancies ?
fct (n, p, q) ;
// appel I
fct (n, x, q) ;
// appel II
fct (x, n, q) ;
// appel III
fct (t, n, &c) ;
// appel IV

Exercice 12:
Soient les dfinitions suivantes de patrons de fonctions :
template <class T, class U> void fct (T a, U b) { ... }
// patron I
template <class T, class U> void fct (T * a, U b) { ... }
// patron II
template <class T> void fct (T, T, T) { ... }
// patron III
void fct (int a, float b) { .....}
// fonction IV
Avec ces dclarations :
int n, p, q ;
float x, y ;
double z ;
Quels sont les appels corrects et, dans ce cas, quels sont les patrons utiliss et les prototypes des fonctions instancies ?
fct (n, p) ;
// appel I
fct (x, y ) ;
// appel II
fct (n, x) ;
// appel III
fct (n, z) ;
// appel IV
fct (&n, p) ;
// appel V
fct (&n, x) ;
// appel VI
fct (&n, &p, &q) // appel VII

Exercice 13:
Soit la dfinition suivante dun patron de classes :
Template <class T, int n> class essai
{ T tab [n] ;
public :
essai (T) ;
// constructeur
};
1) Donnez la dfinition du constructeur essai, en supposant :

quelle est fournie l'extrieur de la dfinition prcdente ;

que le constructeur recopie la valeur reue en argument dans chacun des lments du tableau tab .
2) Disposant ainsi de la dfinition prcdente du patron essai, de son constructeur et de ces dclarations :
const int n = 3 ;
int p = 5 ;
Quelles sont les instructions correctes et les classes instancies ? On en fournira (dans chaque cas) une dfinition
quivalente sous la forme dune classe ordinaire , cest--dire dans laquelle la notion de paramtre a disparu.
essai <int, 10> ei (3) ;
// I
essai <float, n> ef (0.0) ;
// II
essai <double, p> ed (2.5) ;
// III

Exercice 14:
1) Crer un patron de classes nomm pointcol, tel que chaque classe instancie permette de manipuler des points
colors (deux coordonnes et une couleur) pour lesquels on puisse choisir la fois le type des coordonnes
et celui de la couleur. On se limitera deux fonctions membre : un constructeur possdant trois arguments
(sans valeur par dfaut) et une fonction affiche affichant les coordonnes et la couleur dun point color .
2) Dans quelles conditions peut-on instancier une classe patron pointcol pour des paramtres de type classe?

Exercice 15:
On a dfini le patron de classes suivant :
template <class T> class point
{ T x, y ; // coordonnees
public :
point (T abs, T ord) { x = abs ; y = ord ; }
void affiche () ;
};
template <class T> void point<T> :: affiche ()
{ cout << "Coordonnees : " << x << " " << y << "\n" ;
}
1) Que se passe-t-il avec ces instructions :
point <char> p(60, 65) ;
p.affiche () ;
2) Comment faut-il modifier la dfinition de notre patron pour que les instructions prcdentes affichent bien :
Coordonnees : 60 65

Exercice 16 (Facultatif):
1) Crer un patron de classes permettant de reprsenter des vecteurs dynamiques cest--dire des vecteurs
dont la dimension peut ne pas tre connue lors de la compilation (ce nest donc pas obligatoirement une
expression constante comme dans le cas de tableaux usuels). On prvoira que les lments de ces vecteurs
puissent tre de type quelconque.
On sur-dfinira convenablement loprateur [ ] pour quil permette laccs aux lments du vecteur (aussi bien en
consultation quen modification) et on sarrangera pour quil nexiste aucun risque de dbordement dindice . En
revanche, on ne cherchera pas rgler les problmes poss ventuellement par laffectation ou la transmission par
valeur dobjets du type concern.
N.B. Il ne faut pas chercher utiliser les composants standards introduits par la norme. En effet, le patron vector
rpondrait intgralement la question.
2) Comme dans lexercice prcdent, raliser un patron de classes permettant de manipuler des vecteurs dont les
lments sont de type quelconque mais pour lesquels la dimension, suppose tre cette fois une expression constante,
apparatra comme un paramtre (expression) du patron. Hormis cette diffrence, les fonctionnalits du patron
resteront les mmes.

Exercice 17 (Facultatif):
1) On dispose du patron de classes suivant :
template <class T> class point
{ T x, y ; // coordonnees
public :
point (T abs, T ord) { x = abs ; y = ord ; }
void affiche ()
{ cout << "Coordonnees : " << x << " " << y << "\n" ;
}
};
i) Crer, par drivation, un patron de classes pointcol permettant de manipuler des points colors dans
lesquels les coordonnes et la couleur sont de mme type. On redfinira convenablement les fonctions
membre en rutilisant les fonctions membre de la classe de base.
ii) Mme question, mais en prvoyant que les coordonnes et la couleur puissent tre de deux types diffrents.
iii) Toujours par drivation, crer cette fois une classe ordinaire (cest--dire une classe qui ne soit plus un
patron de classes, autrement dit qui ne dpende plus de paramtres...) dans laquelle les coordonnes sont
de type int, tandis que la couleur est de type short.
2) On dispose du mme patron de classes que prcdemment :
template <class T> class point
{
T x, y ;
// coordonnees
public :
point (T abs, T ord) { x = abs ; y = ord ; }
void affiche ()
{ cout << "Coordonnees : " << x << " " << y << "\n" ;
}
};
i) Lui ajouter une version spcialise de affiche pour le cas o T est le type caractre.
ii) Comme dans la question a de lexercice prcdent, crer un patron de classes pointcol permettant de
manipuler des points colors dans lesquels les coordonnes et la couleur sont de mme type.
On redfinira convenablement les fonctions membre en rutilisant les fonctions membre de la classe de
base et lon prvoira une version spcialise de affiche de pointcol dans le cas du type caractre.

Exercice 18 (Facultatif):
On dispose du patron de classes suivant :
template <class T> class point
{ T x, y ; // coordonnees
public :
point (T abs, T ord) { x = abs ; y = ord ; }
void affiche ()
{ cout << "Coordonnees : " << x << " " << y << "\n" ;
}
};
On souhaite crer un patron de classes cercle permettant de manipuler des cercles, dfinis par leur centre (de type
point) et un rayon. On ny prvoira, comme fonctions membre, quun constructeur et une fonction affiche se
contentant dafficher les coordonnes du centre et la valeur du rayon.
i) Le faire par hritage (un cercle est un point qui possde un rayon).
ii) Le faire par composition dobjets membre (un cercle possde un point et un rayon).