Resumen - Clase Matrix

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 47 de 104.

Desafío

Fácil

Construyamos una clase Matrix que reúna todas las técnicas de sobrecarga de operadores que has aprendido en este capítulo. Crearás una matriz con todas las funciones necesarias que admita operaciones aritméticas, comparaciones, acceso a elementos y salida mediante flujo: todo mediante una sintaxis intuitiva de operadores.

Organizarás tu código en dos archivos:

Matrix.h: Define una clase Matrix que administre una matriz 2D de enteros mediante memoria dinámica. Tu matriz debe admitir:
- Miembros privados: un puntero int** para los datos 2D y miembros size_t para las filas y columnas
- Un constructor que reciba las filas y las columnas e inicialice todos los elementos en 0
- Un destructor que libere correctamente toda la memoria asignada
- Un constructor de copia y un operador de asignación de copia (copia profunda con comprobación de autoasignación)
- Los getters getRows() y getCols() (ambos const)
- Un método set(row, col, value) para establecer elementos individuales
- Un método get(row, col) const para recuperar elementos
Implementa estos operadores:
- Aritméticos: + y - para la suma y resta de matrices (devuelven una nueva Matrix por valor)
- Comparación: == y != para comprobar si dos matrices tienen las mismas dimensiones y elementos idénticos
- Flujo: << como función amiga para mostrar la matriz fila por fila, con los elementos separados por espacios y cada fila en una línea nueva
- Subíndice: [], que devuelve un puntero a una fila y permite la sintaxis matrix[row][col] (proporciona versiones const y no const)
Para los operadores aritméticos, supone que ambas matrices tienen las mismas dimensiones. Los operadores de comparación deben devolver false si las dimensiones difieren.
main.cpp: Lee la entrada para crear y manipular dos matrices de 2x2. El formato de entrada es:
1. Cuatro enteros para la primera matriz (fila por fila): a00, a01, a10, a11
2. Cuatro enteros para la segunda matriz (fila por fila): b00, b01, b10, b11
Crea dos objetos Matrix (2 filas y 2 columnas cada uno), rellénalos mediante el método set() y, después, demuestra tus operadores:

Formato de salida:
```
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>
```
Cada fila debe mostrar los elementos separados por espacios individuales. Imprime true o false (en minúsculas) para los resultados de las comparaciones.

Por ejemplo, con las entradas 1 2 3 4 para la matriz A y 5 6 7 8 para la matriz 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() para la conversión de la entrada. Recuerda implementar != en términos de == para mantener la coherencia entre tus operadores. No olvides las protecciones contra inclusiones múltiples en tu archivo de cabecera.

Pruébalo tú mismo

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

using namespace std;

int main() {
    // Lee la entrada para la primera matriz (2x2): a00, a01, a10, a11
    int a00, a01, a10, a11;
    cin >> a00 >> a01 >> a10 >> a11;
    
    // Lee la entrada para la segunda matriz (2x2): b00, b01, b10, b11
    int b00, b01, b10, b11;
    cin >> b00 >> b01 >> b10 >> b11;
    
    // TODO: Crea dos objetos Matrix (2 filas, 2 columnas cada uno)
    
    // TODO: Rellena las matrices usando el método set()
    
    // TODO: Imprime la Matrix A
    // cout << "Matrix A:" << endl;
    // Usa el operador << para imprimir la matriz
    
    // TODO: Imprime la Matrix B
    // cout << "Matrix B:" << endl;
    // Usa el operador << para imprimir la matriz
    
    // TODO: Imprime A + B
    // cout << "A + B:" << endl;
    
    // TODO: Imprime A - B
    // cout << "A - B:" << endl;
    
    // TODO: Mostrar los resultados de la comparación
    // cout << "A == B: " << (usa el ternario para true/false) << endl;
    // cout << "A != B: " << (usa el ternario para true/false) << endl;
    
    // TODO: Mostrar los resultados del acceso por subíndices
    // cout << "A[0][0]: " << ... << endl;
    // cout << "A[1][1]: " << ... << endl;
    
    return 0;
}