Module/Elément : POO-C++

Niveau : 1ère Année

Pr : Ghizlane MOUKHLISS

TP 6

Exercices
Question 1.
Quelles erreurs seront détectées par un compilateur C++ dans ce fichier source qui est accepté par un
compilateur C ?
1 main() {
2 int a=10, b=20, c ;
3 c = g(a, b) ;
4 printf ("valeur de g(%d,%d) = %d", a, b, c) ;
5 }
6 g(int x, int y)
7 {
8 return (x*x + 2*x*y + y*y) ;
9 }

Question 2.
Réaliser une classe point permettant de manipuler un point d’un plan. On prévoira :
— un constructeur recevant en arguments les coordonnées (float) d’un point ;
— une fonction membre deplace effectuant une translation définie par ses deux arguments (float) ;
— une fonction membre affiche se contentant d’afficher les coordonnées cartésiennes du point.

Les coordonnées du point seront des membres donnée privés. On écrira séparément :
— un fichier source constituant la déclaration de la classe ;
— un fichier source correspondant à sa définition.

Écrire, par ailleurs, un petit programme d’essai (main) déclarant un point, l’affichant, le déplaçant
etl’affichant à nouveau.

Question 3.
Réaliser une classe point, analogue à la précédente, mais ne comportant pas de fonction affiche.
Pour respecter le principe d’encapsulation des données, prévoir deux fonctions membre publiques
(nommées abscisse et ordonnee) fournissant en retour l’abscisse et l’ordonnée d’un point. Adapter le
petit programme d’essai précédent pour qu’il fonctionne avec cette nouvelle classe.

Question 4.
Ajouter à la classe précédente (comportant un constructeur et trois fonctions membre deplace,
abscisse et ordonnee) de nouvelles fonctions membre :
— homothetie qui effectue une homothétie dont le rapport est fourni en argument;
— rotation qui effectue une rotation dont l’angle est fourni en argument ;
— rho et theta qui fournissent en retour les coordonnées polaires du point.
 Question 5.
Soit la classe point créée dans la Question 2, dont la déclaration était la suivante :
1 main() {
2 int a=10, b=20, c ;
3 c = g(a, b) ;
4 printf ("valeur de g(%d,%d) = %d", a, b, c) ;
5 }
6

7 g(int x, int y)
8 {
9 return (x*x + 2*x*y + y*y) ;
10 }
Adapter cette classe, de manière que la fonction membre affiche fournisse, en plus des coordonnées
du point, le nombre d’objets de type point.

Question 6.
Réaliser une classe nommée set_char permettant de manipuler des ensembles de caractères. On
devra pouvoir réaliser sur un tel ensemble les opérations classiques suivantes : lui ajouter un nouvel
élément, connaître son "cardinal" (nombre d’éléments), savoir si un caractère donné lui appartient.
Ici, on n’effectuera aucune allocation dynamique d’emplacements mémoire. Il faudra donc prévoir, en
membre donnée, un tableau de taille fixe.
Ecrire, en outre, un programme (main) utilisant la classe set_char pour déterminer le nombre de caractères
différents contenus dans un mot lu en donnée.

Question 7.
On souhaite réaliser une classe vecteur3d permettant de manipuler des vecteurs à trois composantes.
On prévoit que sa déclaration se présente ainsi :
1 Class vecteur3d
{float x, y, z // pour les 3 composantes (cartésiennes)
.....} ;

On souhaite pouvoir déclarer un vecteur, soit en fournissant explicitement ses trois composantes, soit en en
fournissant aucune, auquel cas le vecteur créé possédera trois composantes nulles. écrire le ou les constructeurs
correspondants :
- en utilisant des fonctions membre surdéfinies ;
- en utilisant une seule fonction membre ;
- en utilisant une seule fonction en ligne.

Question 8.
Soit une classe vecteur3d définie comme suit :
1 class vecteur3d
2 Float x,y,z ;
3 public :vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0)
4 { x = c1 y =c2 z = c3 ; }
5 ..... }
6 ;
Introduire une fonction membre nommée coincide permettant de savoir si deux vecteurs ont les
mêmes composantes :
— en utilisant une transmission par valeur ;
— en utilisant une transmission par adresse ;
— en utilisant une transmission par référence.
Si v1 et v2 désignent 2 vecteurs de type vecteur3d, comment s’écrit le test de coïncidence de ces 2
vecteurs, dans chacun des 3 cas considérés ?

Question 9.
Comment concevoir le type classe chose de façon que ce petit programme :
1 main()
2 {chose x ;
3 cout « "bonjour\n" ;
4 }
Fournisse les résultats suivants :
- Création objet de type chose
- bonjour
- destruction objet de type chose
Que fournira alors l’exécution de ce programme (utilisant le même type chose) :
1 main() {chose * adc = new chose}

Question 10.
Quels seront les résultats fournis par l’exécution du programme suivant (ici, la déclaration de la classe
demo, sa définition et le programme d’utilisation ont été regroupés en un seul fichier) :
include <iostream>
using namespace std;
class demo
{ int x,y;
public :
demo (int abs=1, int ord=0) // Constructeur I (0,1 ou 2 arguments)
{x=abs; y=ord ;
cout « "constructeur I : " « x « " " « y « "\n" ;
}

demo (demo &); // Constructeur II (par copie)

~demo () ; // destructeur
};

demo ::demo (demo & d) // ou demo :: demo ( const demo & d)

{cout « "constructeur II (recopie) :" « d.x « " " « d.y « "\n" ;
x=d.x ; y=d.y ;
}
Demo ::~demo ()
{ cout«"destruction : "« x «" "« y «"\n" ;
}

main ()
{ void fct (demo, demo *); // proto function indépendante fct
cout « "debut main\";
demo a;
demo b = 2;
demo c = a;
 demo * adr = new demo (3,3);

fct (a, adr);

demo d = demo (4,4);
c = demo (5,5);
cout « "fin main\n";
}
void fct (demo d, demo * add)
{ cout « "entrée fct\n";
delete add;
cout « "sortie fct\n" ;
}

Question 11.
Créer une classe point ne contenant qu’un constructeur sans arguments, un destructeur et un membre
donnée privé représentant un numéro de point (le premier créé portera le numéro 1, le suivant le
numéro 2...). Le constructeur affichera le numéro du point créé et le destructeur affichera le numéro du
point détruit. Ecrire un petit programme d’utilisation créant dynamiquement un tableau de 4 points et
ledétruisant.

Question 12.
1. Réaliser une classe nommée set_int permettant de manipuler des ensembles de nombres entiers.
On devra pouvoir réaliser sur un tel ensemble les opérations classiques suivantes : lui ajouter un nouvel
élément, connaître son cardinal (nombre d’éléments), savoir si un entier donné lui appartient.

Ici, on conservera les différents éléments de l’ensemble dans un tableau alloué dynamiquement par
le constructeur. Un argument (auquel on pourra prévoir une valeur par défaut) lui précisera le nombre
maximal d’éléments de l’ensemble.

2. écrire, en outre, un programme (main) utilisant la classe set_int pour déterminer le nombre d’entiers
différents contenus dans 20 entiers lus en données.

3. Que faudrait-il faire pour qu’un objet du type set_int puisse être transmis par valeur, soit comme
argument d’appel, soit comme valeur de retour d’une fonction ?

Question 13.
Soit la classe point suivante :
1 class point
2 {int x,y ;
public :
3 point (int abs=0, int ord=0)
4 {x = abs ; y = ord ;
5 }
6 };
Ecrire une fonction indépendante affiche, amie de la classe point, permettant d’afficher les coordonnées d’un
point. On fournira séparément un fichier source contenant la nouvelle déclaration (définition) de point
et un fichier source contenant la définition de la fonction affiche. Écrire un petit programme (main) qui
crée un point de classe automatique et un point de classe dynamique et qui en affiche les coordonnées.
 Question 14.
Créer deux classes (dont les membres donnée sont privés) :
— l’une, nommée vect, permettant de représenter des vecteurs à 3 composantes de type double ; elle
comportera un constructeur et une fonction membre d’affichage ;
— l’autre, nommée matrice, permettant de représenter des matrices carrées de dimension 3 x 3 ; elle
comportera un constructeur avec un argument (adresse d’un tableau de 3 x 3 valeurs) qui initialisera la
matrice avec les valeurs correspondantes.

Réaliser une fonction indépendante prod permettant de fournir le vecteur correspondant au produit
d’une matrice par un vecteur. Écrire un petit programme de test. On fournira séparé- ment les deux
déclarations de chacune des classes, leurs deux définitions, la définition de prod et le programme de test.

Question 15.
Soit une classe vecteur3d définie comme suit :
1 class vecteur3d
2 {float x,y,z ;
3 public :
3 vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0)
4 { x = c1 ; y =c2 ; z = c3 ;
}
};
Définir les opérateurs == et != de manière qu’ils permettent de tester la coïncidence ou la non-coïncidencede
deux points :
a. en utilisant des fonctions membre ;
b. en utilisant des fonctions amies.

Question 16.
Soit la classe vecteur3d ainsi définie :
1 class vecteur3d
2 {float x,y,z ;
public :
3 vecteur3d (float c1=0.0, float c2=0.0, float c3=0.0)
4 { x = c1 ; y =c2 ; z = c3 ;}
5 };
Définir l’opérateur binaire + pour qu’il fournisse la somme de deux vecteurs, et l’opérateur binaire *
pour qu’il fournisse le produit scalaire de deux vecteurs. On choisira ici des fonctions amies.

Question 17.
Soit la classe point suivante :
1 class point
2 {int x,y ;
public :
3 point (int abs=0, int ord=0)
4 {x = abs ; y = ord ;
5 }
6 //...
7 };
 a. La munir d’un opérateur de cast permettant de convertir un point en un entier (correspondant à son abscisse).

b. Soient alors ces déclarations :

1 point p ;
2 int n ;
3 void fct (int) ;
4

Que font ces instructions :

n = p ; // instruction 1
fct (p) ; // instruction 2

Question 18.
Quels résultats fournira le programme suivant :
#include <iostream>
using namespace std;
class point
{ int x,y;
Public:
point (int abs, int ord) // Constructeur 2 arguments
{x = abs y = ord ;
}
operator int() // "cast" point -> int
{cout«"*** appel int()pour le point " « x «" "«y«"\n" ;
return x;
}
};
main()
{ point a(1,5), b(2,8)
int n1, n2, n3
n1 = a + 3 ; // instruction 1
cout « "n1 = " « n1 « "\n" ;
n2 = a + b ; // instruction 2
cout « "n2 = " « n2 « "\n" ;
double z1, z2 ;
z1 = a + 3 ; // instruction 3
cout « "z1 = "« z1 « "\n" ;
z2 = a + b ; // instruction 4
cout « "z2 = " « z2 « "\n" ;
}
Question 19.
Soient les deux classes suivantes :
1 class B
2 { //...
3 public :
3 B () ; // constructeur sans argument
5 B (int) ; // constructeur à un argument entier
6 // ...
7 };

8 class A
{ //...friend operator + (A, A);
11 public :
12 A () ; // constructeur sans argument
13 A (int) ; // constructeur aÌĂ un argument entier
14 A (B) ; // constructeur aÌĂ un argument entier de type B
15 // ...
16 };
a. Dans un programme contenant les déclarations :
1 A a1, a2, a3 ;
2 B b1, b2, b3 ;

Les instructions suivantes seront-elles correctes et, si oui, que feront-elles ?

1 a1 = b1 ; // instruction 1
2 b1 = a1 ; // instruction 2
3 a3=a1+a2 ; //instruction3
4 a3=b1+b2 ; //instruction4
5 b3=a1+a2 ; //instruction5

b. Comment obtenir le même résultat sans définir, dans A, le constructeur A(B) ?

Question 20.
Quels seront les résultats fournis par ce programme :
1 include <iostream>
2 using namespace std;
3 class A
4 {int n;
5 float x;
6 public:
8 A (int p = 2)
9 { n=p;x=1;
9 cout « "** construction objet A: " « n « " " « x « "\n" ;
10 }
11 } ;
9

10 class B
11 { int n;
11

12 float y;
13 public :
14 B (float v = 0.0)
{n=1; y=v ;
15 cout « "** construction objet B : " « n « " " « y « "\n" ;
}
16

17 class C : public B, public A

18 {int n;
19 int p;
20 public :
21 C (int n1=1, int n2=2, int n3=3, float v=0.0): A (n1), B(v)
{ n =n3; p = n1+n2;
22 cout « "** construction objet C : " « n « " " « p «"\n" ;
23 }
};
24 main()
{C c1 ;
C c2 (10, 11, 12, 5.0) ;

Bon courage ! ! !