Ripasso - Classe Matrix

Fa parte della sezione Programmazione orientata agli oggetti del percorso C++ di Coddy. Lezione 47 di 104.

Sfida

Facile

Costruiamo una classe Matrix che riunisce tutte le tecniche di sovraccarico degli operatori che hai imparato in questo capitolo. Creerai una matrice completa che supporta operazioni aritmetiche, confronti, accesso agli elementi e output su stream: tutto tramite una sintassi intuitiva degli operatori.

Organizzerai il codice in due file:

Matrix.h: Definisci una classe Matrix che gestisce un array bidimensionale di interi usando la memoria dinamica. La matrice deve supportare:
- Membri privati: un puntatore int** per i dati bidimensionali e membri size_t per righe e colonne
- Un costruttore che accetta righe e colonne e inizializza tutti gli elementi a 0
- Un distruttore che libera correttamente tutta la memoria allocata
- Un costruttore di copia e un operatore di assegnazione per copia (copia profonda con controllo dell'autoassegnazione)
- I getter getRows() e getCols() (entrambi const)
- Un metodo set(row, col, value) per impostare singoli elementi
- Un metodo const get(row, col) per recuperare gli elementi
Implementa questi operatori:
- Aritmetici: + e - per l'addizione e la sottrazione di matrici (restituiscono una nuova Matrix per valore)
- Confronto: == e != per verificare se due matrici hanno le stesse dimensioni e gli stessi elementi
- Stream: << come funzione friend per visualizzare la matrice riga per riga, con gli elementi separati da spazi e ogni riga su una nuova linea
- Indice: [] che restituisce un puntatore a una riga, consentendo la sintassi matrix[row][col] (fornisci sia la versione const sia quella non const)
Per gli operatori aritmetici, supponi che entrambe le matrici abbiano le stesse dimensioni. Gli operatori di confronto devono restituire false se le dimensioni differiscono.
main.cpp: Leggi l'input per creare e manipolare due matrici 2x2. Il formato dell'input è:
1. Quattro interi per la prima matrice (riga per riga): a00, a01, a10, a11
2. Quattro interi per la seconda matrice (riga per riga): b00, b01, b10, b11
Crea due oggetti Matrix (ciascuno con 2 righe e 2 colonne), popola le matrici usando il metodo set(), quindi mostra i tuoi operatori:

Formato dell'output:
```
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>
```
Ogni riga deve mostrare gli elementi separati da singoli spazi. Stampa true o false (in minuscolo) per i risultati dei confronti.

Ad esempio, con gli input 1 2 3 4 per Matrix A e 5 6 7 8 per 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

Usa std::stoi() per la conversione dell'input. Ricorda di implementare != in termini di == per mantenere coerenti i tuoi operatori. Non dimenticare le guardie di inclusione nel file header.

Provalo tu

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

using namespace std;

int main() {
    // Leggi l'input per la prima matrice (2x2): a00, a01, a10, a11
    int a00, a01, a10, a11;
    cin >> a00 >> a01 >> a10 >> a11;
    
    // Leggi l'input per la seconda matrice (2x2): b00, b01, b10, b11
    int b00, b01, b10, b11;
    cin >> b00 >> b01 >> b10 >> b11;
    
    // TODO: Crea due oggetti Matrix (2 righe e 2 colonne ciascuno)
    
    // TODO: Popola le matrici usando il metodo set()
    
    // TODO: Stampa Matrix A
    // cout << "Matrix A:" << endl;
    // Usa l'operatore << per stampare la matrice
    
    // TODO: Stampa Matrix B
    // cout << "Matrix B:" << endl;
    // Usa l'operatore << per stampare la matrice
    
    // TODO: Stampa A + B
    // cout << "A + B:" << endl;
    
    // TODO: Stampa A - B
    // cout << "A - B:" << endl;
    
    // TODO: Visualizza i risultati del confronto
    // cout << "A == B: " << (usa l'operatore ternario per true/false) << endl;
    // cout << "A != B: " << (usa l'operatore ternario per true/false) << endl;
    
    // TODO: Visualizza i risultati dell'accesso tramite indice
    // cout << "A[0][0]: " << ... << endl;
    // cout << "A[1][1]: " << ... << endl;
    
    return 0;
}