Université Cadi Ayyad Année universitaire : 2019 – 2020

ENSA de Marrakech

Langage C/C++
TD n°4.

Exercice 0:
Réaliser une classe String permettant de gérer les chaînes de caractères. Elle contient alors un attribut de type
« char « la classe doit fournir les services suivants :
1. Un constructeur avec un paramètre de type char contenu de la chaîne.

2. Surcharger le constructeur pour accepter un entier ; même chose pour un réel et un caractère.

3. Un destructeur-.

4. Les méthodes suivantes :

- int length() qui retourne la taille de la chaîne.

- char get(int i) qui retourne le caractère numéro i.

- void set(int i, char c) qui remplace le caractère numéro i par le caractère ‘c’.

- void set(char* string) qui remplace le contenu de la chaîne par la chaîne string.

- Surcharger la méthode set pour accepter un entier ; même chose pour un réel et un caractère .

- void append(char *string) : concaténation avec string .

- Surcharger la méthode append pour accepter un entier ; même chose pour un réel et un caractère.

- void toUpper() : convertir en majuscule.

- void toLower( ) : convertir en minuscule.

- void insert(int i, char* string) : insertion d’une chaîne " string à la position i.

- void insert(int i, String string) : insertion d’une chaîne " string à la position i.

- Surcharger la méthode insert pour accepter en deuxième paramètre un entier ; même chose pour un réel et
un caractère.

- String substring(int i, int j) qui extrait la sous chaîne située entre i et j.

- void print( ), pour l’affichage.

- int intValue) : permettant de retourner sous forme d’entier le contenu de la chaîne si c’est un entier.

- double doubleValue() : permettant de retourner sous forme de réel le contenu de la chaîne si c’est un réel.

5. Surcharger les opérateurs + pour la concaténation des chaînes, et = pour les affectations entre chaînes.

Remarque : il existe une classe standard en C++ classe string ( s miniscule) #include <string> qui permet la
manipulation des chaines de caractères. Le but de cet exercice est de voir comment elle est définie.
Exercice 1 :
On dispose d’un fichier nommé point.h contenant la déclaration 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 coordonnées : " << x << " " << y << "\n" ;
}
float abs () { return x ; }
float ord () { return y ; }
};
1. Créer une classe pointb, dérivée de point comportant simplement une nouvelle fonction membre nommée
rho, fournissant la valeur du rayon vecteur (première coordonnée polaire) d’un point.
2. Même question, en supposant que les membres x et y ont été déclarés protégés (protected) dans point, et
non plus privés.
3. Introduire un constructeur dans la classe pointb.
4. Quelles sont les fonctions membre utilisables pour un objet de type pointb ?

Exercice 2:
On garde la classe Point de l’exercice précédent.
1. Créer une classe PointCol, dérivée de Point comportant un attribut de type char* couleur.
2. Définir dans les 2 classes un constructeur de copie.
3. Surchargez dans les 2 classes l’opérateur d’affectation.

Exercice 3: sur papier

Quels résultats produira ce programme :
#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 coordonnées 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 coordonnées sont : " << x << " " << y ;
cout << " et ma couleur est : " << couleur << "\n" ;
}
};
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 4:
1) reprendre la classe Vecteur3D, et surcharger les opérateurs d’entrée sortie pour les Vecteur3D.
Pour l’affichage : (abs, ord, cote)
Pour la saisie : abs ord cote
2) Idem pour la classe Pile.

Exercice 5: Template
Rendre la classe Vecteur3D une classe template qui permet de créer des vecteurs de coordonnées de tous
types.

Exercice 6 : exo de synthèse à faire sur papier

On a les déclarations et définitions suivantes:
#include <iostream.h>
class Bubu { public:
int x;
Bubu(int);
~Bubu();
};
class Toto { public:
Bubu * pbu;
int y;
Toto(int, int);
~Toto();
};
class Titi: public Toto { public:
int z;
Titi(int, int, int);
~Titi();
};
Titi::Titi(int a, int b, int c) : Toto(a, a+b) {
cout << "++ Titi debut" << endl;
z = c;
cout << "++ Titi z = " << z << endl;
cout << "++ Titi fin" << endl;
}
Titi::~Titi() : {
cout << "-- Titi debut z = " << z << endl;
cout << "-- Titi fin" << endl;
}
Toto::Toto(int a, int b) {
cout << "++ Toto debut" << endl;
y = b;
cout << "++ Toto y = " << y << endl;
pbu = new Bubu(a);
cout << "++ Toto fin" << endl;
}
Toto::~Toto() {
cout << "-- Toto debut y = " << y << endl;
delete pbu;
cout << "-- Toto fin" << endl;
}
Bubu::Bubu(int a) {
cout << "++ Bubu debut" << endl;
x = a;
cout << "++ Bubu x = " << x << endl;
cout << "++ Bubu fin" << endl;
}
Bubu::~Bubu(int a) {
cout << "-- Bubu debut x = " << x << endl;
cout << "-- Bubu fin" << endl;
}
main() {
Toto to(1, 2);
Titi ti(3, 4, 5);
}
 1. Donner la sortie du programme.
2. On ajoute la fonction membre imprimer() dans la classe Toto et on modifie le main() :
class Toto { public: ... void imprimer(); ... };
Toto::imprimer() {
cout << "Toto::imprimer: " << pbu->x << " " << y << endl;
}
main () {
Toto to(6, 7);
Titi ti(8, 9, 0);
to.imprimer(); // instruction A
ti.imprimer(); // instruction B
}
Donner la sortie des instructions A et B.
3. On ajoute la fonction membre imprimer() dans la classe Titi :
class Titi: public Toto { public: ... void imprimer( ); ... };
Titi::imprimer() {
cout << "Titi::imprimer: " << pbu->x << " " << y << " " << z << endl;
}
Donner la sortie des instructions A et B de la question précédente.
4. On modifie le programme principal :
main () {
Toto to(44, 55);
Titi ti(11, 22, 33);
Toto * pto;
Titi * pti;
pto = &to;
pti = &ti;
pto->imprimer(); // instruction A
pti->imprimer(); // instruction B
pto = pti;
pto->imprimer(); // instruction C
}
Donner la sortie des instructions A, B et C.
5. On ajoute le mot-clé virtual devant la fonction membre imprimer de la classe Toto :
class Toto { public: ... virtual void imprimer(); ... };
Donner la sortie des instructions A, B, C de la question précédente.