Récapitulatif – Classe Matrix

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 47 sur 104.

Défi

Facile

Construisons une classe Matrix qui réunit toutes les techniques de surcharge des opérateurs que tu as apprises dans ce chapitre. Tu vas créer une matrice complète qui prend en charge les opérations arithmétiques, les comparaisons, l’accès aux éléments et l’affichage dans un flux, le tout au moyen d’une syntaxe intuitive faisant appel aux opérateurs.

Tu organiseras ton code dans deux fichiers :

Matrix.h : définis une classe Matrix qui gère un tableau 2D d’entiers à l’aide de mémoire dynamique. Ta matrice doit prendre en charge :
- Membres privés : un pointeur int** pour les données 2D et des membres size_t pour les lignes et les colonnes
- Un constructeur qui prend le nombre de lignes et de colonnes et initialise tous les éléments à 0. Alloue un tableau de pointeurs de lignes, puis chaque ligne : data = new int*[rows]; et data[r] = new int[cols]; pour chaque ligne r
- Un destructeur qui libère correctement toute la mémoire allouée : delete[] chaque ligne d’abord, puis delete[] data;
- Un constructeur de copie et un opérateur d’affectation par copie (copie profonde avec vérification de l’auto-affectation)
- Des accesseurs getRows() et getCols() (tous deux const)
- Une méthode set(row, col, value) pour définir des éléments individuels
- Une méthode const get(row, col) pour récupérer les éléments
Implémente ces opérateurs :
- Arithmétiques : + et - pour l’addition et la soustraction de matrices (renvoient une nouvelle Matrix par valeur)
- Comparaison : == et != pour vérifier si deux matrices ont les mêmes dimensions et des éléments identiques
- Flux : << comme fonction amie pour afficher la matrice ligne par ligne, avec les éléments séparés par des espaces et chaque ligne sur une nouvelle ligne
- Indice : [] qui renvoie un pointeur vers une ligne, permettant la syntaxe matrix[row][col] (fournis les versions const et non const)
Pour les opérateurs arithmétiques, suppose que les deux matrices ont les mêmes dimensions. Les opérateurs de comparaison doivent renvoyer false si les dimensions diffèrent.
main.cpp : lis les données d’entrée pour créer et manipuler deux matrices 2x2. Le format d’entrée est le suivant :
1. Quatre entiers pour la première matrice (ligne par ligne) : a00, a01, a10, a11
2. Quatre entiers pour la deuxième matrice (ligne par ligne) : b00, b01, b10, b11
Crée deux objets Matrix (2 lignes et 2 colonnes chacun), remplis-les à l’aide de la méthode set(), puis illustre tes opérateurs :

Format de sortie :
```
Matrix A:
<row0>
<row1>
Matrix B:
<row0>
<row1>
A + B:
<row0>
<row1>
A - B:
<row0>
<row1>
A == B: <true/false>
A != B: <true/false>
A[0][0]: <value>
A[1][1]: <value>
```
Chaque ligne doit afficher les éléments séparés par un seul espace. Affiche true ou false (en minuscules) pour les résultats des comparaisons.

Par exemple, avec les entrées 1 2 3 4 pour la matrice A et 5 6 7 8 pour Matrix B:

Matrix A:
1 2
3 4
Matrix B:
5 6
7 8
A + B:
6 8
10 12
A - B:
-4 -4
-4 -4
A == B: false
A != B: true
A[0][0]: 1
A[1][1]: 4

N’oublie pas d’implémenter != en fonction de == pour que tes opérateurs restent cohérents. N’oublie pas non plus les gardes d’inclusion dans ton fichier d’en-tête.

Essayez vous-même

#include <iostream>
#include <string>
#include "Matrix.h"

using namespace std;

int main() {
    // Lire les valeurs de la première matrice (2x2) : a00, a01, a10, a11
    int a00, a01, a10, a11;
    cin >> a00 >> a01 >> a10 >> a11;
    
    // Lire les valeurs de la deuxième matrice (2x2) : b00, b01, b10, b11
    int b00, b01, b10, b11;
    cin >> b00 >> b01 >> b10 >> b11;
    
    // TODO: Créer deux objets Matrix (2 lignes et 2 colonnes chacun)
    
    // TODO: Remplir les matrices à l’aide de la méthode set()
    
    // TODO: Afficher Matrix A
    // cout << "Matrix A:" << endl;
    // Utiliser l’opérateur << pour afficher la matrice
    
    // TODO: Afficher Matrix B
    // cout << "Matrix B:" << endl;
    // Utiliser l’opérateur << pour afficher la matrice
    
    // TODO: Afficher A + B
    // cout << "A + B:" << endl;
    
    // TODO: Afficher A - B
    // cout << "A - B:" << endl;
    
    // TODO: Afficher les résultats des comparaisons
    // cout << "A == B: " << (utiliser l’opérateur ternaire pour true/false) << endl;
    // cout << "A != B: " << (utiliser l’opérateur ternaire pour true/false) << endl;
    
    // TODO: Afficher les résultats des accès par indice
    // cout << "A[0][0]: " << ... << endl;
    // cout << "A[1][1]: " << ... << endl;
    
    return 0;
}