P.O.O.

en C++
Master 1 INS3I
TP 4 : Matrices P.-A. Hébert
2018–2019

Consignes
Dans ce TP vous allez concevoir 3 classes destinées à représenter des matrices :
sans gestion de la mémoire, puis de manière dynamique (automatisée, puis manuelle).

1 Matrices « sans gestion dynamique de la mémoire »

1.1 Définition de la classe Matrice1
On souhaite manipuler des matrices sans gestion dynamique de la mémoire. Leurs dimen-
sions, doivent donc être définies avant compilation. Elles seront ici fixées à 10 × 10.
Dans cette première classe, chaque objet Matrice1 contiendra un tableau de 10 tableaux de
10 float, défini par l’instruction :

array< array<float,10> > reels;

Chacun des 10 tableaux (les éléments de reels) représente une ligne possible de la matrice
(10 lignes sont réservées, mais la matrice peut en exploiter moins que 10).
De même, chaque colonne est constituée de 10 variables float, mais rien n’empêche d’en
exploiter moins.
C’est pourquoi, les dimensions effectives de chaque objet Matrice1 devront être mémorisées
dans l’objet, en plus de son espace de 10 × 10 éléments.

Q 1. Dans le fichier d’en-tête de cette classe, matrice1.hpp, proposez une déclaration mini-
male de cette classe, comprenant - outre ses données membres :
— un constructeur par défaut : qui crée une matrice de dimensions 0 × 0 ;
— un constructeur permettant d’initialiser une matrice de dimensions demandées (si
possible), dont toutes les valeurs sont nulles ;
— un autre constructeur très similaire au précédent, mais qui permet de choisir la valeur
initiale de ses éléments (tous égaux là encore).

N’oubliez pas de bien séparer l’interface de la classe de sa structure interne.

1.2 Développement des méthodes

Vous définirez les méthodes dans le fichier source de la classe, matrice1.cpp, et compléterez
si nécessaire le fichier d’en-tête de la classe.

Et vous testerez au fur et à mesure ses fonctions dans un fichier source indépendant :
main.cpp, qui essentiellement la fonction main.

Q 2. Programmez les constructeurs et la fonction d’affichage.

Puis testez-les en affichant une matrice vide, une matrice 10×10 remplie de 0, et une matrice
3 × 4 remplie de 1.
Dans les questions suivantes, les tests ne seront plus demandés explicitement, mais ils devront
être faits, en suivant cet exemple.

Q 3. Proposez une méthode (à la fois accesseur et mutateur), qui renvoie une référence sur
l’élément de la matrice désigné par ses coordonnées.
Puis surchargez l’opérateur [] avec ce traitement.

Q 4. Écrivez une méthode d’ajout, qui ajoute à chaque élément de la matrice invoqué,
l’élément correspondant de la matrice passée en paramètre.
Puis surchargez l’opérateur += pour effectuer ce traitement.

Q 5. Recommencez pour pouvoir ajouter à tout élément de la matrice, une valeur constante
réelle.

Q 6. Écrivez une fonction réalisant l’opération d’addition, sans utiliser la structure interne
de la matrice. Vous en ferez par conséquent une fonction externe à la classe.

2 Matrices « avec gestion dynamique de la mémoire », version

« automatisée »
Proposez une nouvelle classe Matrice2, munie d’une gestion dynamique de la mémoire, dans
2 fichiers matrice2.hpp et matrice.cpp.

Contrairement à la version précédente, chaque objet Matrice2 ne contiendra donc ni plus, ni

moins, de variables float que la quantité déterminée par ses dimensions : il y a dont égalité
entre dimensions « effectives » et dimensions « potentielles ».

Dans cette première version, la gestion dynamique sera automatisée, car prise en charge par
une classe conteneur de la STL : vous remplacerez les std::array par des std::vector.
Ce sont les méthodes de la classe qui feront les allocations et désallocations mémoire relatives
aux éléments des objets Matrice2.

Il n’y a donc plus de limite de dimensions. Assurez-vous de bien répercuter le passage des
std::array aux std::float partout dans le code source de la classe.

3 Matrices « avec gestion dynamique de la mémoire », version

« non automatisée »
3.1 Définition de la classe Matrice3
On souhaite toujours optimiser la gestion mémoire des matrices, mais cette voici de manière
« manuelle » : vous n’utiliserez donc pas la classe std::vector !

2
Q 1. Dans un fichier matrice2.hpp proposez la définition de la nouvelle classe matrice, en
reprenant les consignes précédentes, à quelques différences près :
— les éléments de la matrice étant gérés de manière dynamique, à base d’instructions new
et delete, chaque objet Matrice3 aura besoin d’un pointeur pour conserver l’adresse
de leur espace mémoire.
Les données de la matrice pourront être stockées les unes derrière les autres, ligne par
ligne. Mais il est également aussi possible de gérer des tableaux de tableaux, comme
dans les versions précédentes (mais cette fois-ci de manière dynamique et explicite).
— l’espace mémoire des données de la matrice sera alloué consécutivement à l’alloca-
tion/définition de l’objet Matrice3 (et donc dans son constructeur).
— il sera par ailleurs désalloué consécutivement à la désallocation de l’objet Matrice3
(et donc dans son destructeur).

3.2 Développement des méthodes

Reprenez l’ensemble du développement précédent dans un nouveau fichier matrice3.cpp, sans
oublier le destructeur, et la nouvelle fonctionnalité du constructeur (allocateur de mémoire).

3.3 Comparaison à la classe précédente

Q 2. À l’aide de la fonction sizeof, comparez la taille d’un objet Matrice1 et d’un objet
Matrice3 représentant tous deux une matrice de dimensions 4 × 4.
Expliquez.

Q 3. Comparez - expérimentalement et théoriquement - la fonctionnalité d’affectation entre

2 objets matrices déjà construits, avec et sans gestion de la mémoire.

Q 4. Proposez une surcharge de l’opérateur d’affectation pour régler le problème de la classe

Matrice3.
Puis corrigez de la même manière son « constructeur de recopie » (cf. cours).