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 d'opérateurs que vous avez apprises dans ce chapitre. Vous allez créer une matrice complète qui prend en charge les opérations arithmétiques, les comparaisons, l'accès aux éléments et la sortie de flux — le tout via une syntaxe d'opérateur intuitive.

Vous organiserez votre code sur deux fichiers :

Matrix.h : Définissez une classe Matrix qui gère un tableau 2D d'entiers en utilisant la mémoire dynamique. Votre matrice doit prendre en charge :
- Membres privés : un pointeur int** pour les données 2D, et des membres size_t pour les lignes (rows) et les colonnes (cols)
- Un constructeur qui prend les lignes et les colonnes, 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 des éléments individuels
- Une méthode const get(row, col) pour récupérer des éléments
Implémentez ces opérateurs :
- Arithmétique : + et - pour l'addition et la soustraction de matrices (retournent une nouvelle Matrix par valeur)
- Comparaison : == et != pour vérifier si deux matrices ont les mêmes dimensions et des éléments identiques
- Flux : << en tant que fonction amie (friend) 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] (fournissez les versions const et non-const)
Pour les opérateurs arithmétiques, supposez que les deux matrices ont les mêmes dimensions. Les opérateurs de comparaison doivent retourner false si les dimensions diffèrent.
main.cpp : Lisez l'entrée pour créer et manipuler deux matrices 2x2. Le format d'entrée est :
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éez deux objets Matrix (2 lignes, 2 colonnes chacun), remplissez-les à l'aide de la méthode set(), puis faites la démonstration de vos 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. Affichez true ou false (en minuscules) pour les résultats de comparaison.

Par exemple, avec les entrées 1 2 3 4 pour la Matrix A et 5 6 7 8 pour la 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

Utilisez std::stoi() pour la conversion des entrées. N'oubliez pas d'implémenter != en fonction de == pour maintenir la cohérence de vos opérateurs. N'oubliez pas les gardes d'inclusion (header guards) dans votre 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 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, 2 colonnes chacun)
    
    // TODO: Remplir les matrices en utilisant la méthode set()
    
    // TODO: Afficher la Matrix A
    // cout << "Matrix A:" << endl;
    // Utiliser l'opérateur << pour afficher la matrice
    
    // TODO: Afficher la 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 la comparaison
    // cout << "A == B: " << (utiliser une ternaire pour true/false) << endl;
    // cout << "A != B: " << (utiliser une ternaire pour true/false) << endl;
    
    // TODO: Afficher les résultats de l'accès par indice
    // cout << "A[0][0]: " << ... << endl;
    // cout << "A[1][1]: " << ... << endl;
    
    return 0;
}