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 rassemble toutes les techniques de surcharge des opérateurs que tu as apprises dans ce chapitre. Tu vas créer une matrice complète prenant en charge les opérations arithmétiques, les comparaisons, l’accès aux éléments et l’affichage dans un flux : le tout grâce à une syntaxe d’opérateurs intuitive.

Tu organiseras ton code sur deux fichiers :

Matrix.h : définir 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 accepte le nombre de lignes et de colonnes, en initialisant tous les éléments à 0
- Un destructeur qui libère correctement toute la mémoire allouée
- 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 les éléments individuellement
- Une méthode get(row, col) const pour récupérer les éléments
Implémente ces opérateurs :
- Arithmétiques : + et - pour l’addition et la soustraction de matrices (retourner une nouvelle Matrix par valeur)
- Comparaison : == et != pour vérifier que deux matrices ont les mêmes dimensions et des éléments identiques
- Flux : << en tant que 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 retourne un pointeur vers une ligne, permettant la syntaxe matrix[row][col] (fournir des 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 retourner false si les dimensions diffèrent.
main.cpp : lire l’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 démontre 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 des espaces simples. 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 la matrice 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

Utilise std::stoi() pour la conversion de l’entrée. N’oublie pas d’implémenter != en fonction de == afin de conserver la cohérence de tes opérateurs. N’oublie pas non plus les protections 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 l'entrée pour la première matrice (2x2) : a00, a01, a10, a11
    int a00, a01, a10, a11;
    cin >> a00 >> a01 >> a10 >> a11;
    
    // Lire l'entrée pour la seconde matrice (2x2) : b00, b01, b10, b11
    int b00, b01, b10, b11;
    cin >> b00 >> b01 >> b10 >> b11;
    
    // TODO: Créer deux objets Matrix (2 lignes, 2 colonnes chacun)
    
    // TODO: Remplir les matrices en utilisant 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 de comparaison
    // cout << "A == B: " << (utiliser le ternaire pour true/false) << endl;
    // cout << "A != B: " << (utiliser le ternaire pour true/false) << endl;
    
    // TODO: Afficher les résultats d'accès par indice
    // cout << "A[0][0]: " << ... << endl;
    // cout << "A[1][1]: " << ... << endl;
    
    return 0;
}