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

Vamos a construir 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 de flujo, todo a través de una sintaxis de operadores intuitiva.

Organizarás tu código en dos archivos:

Matrix.h: Define una clase Matrix que gestione un arreglo bidimensional de enteros utilizando memoria dinámica. Tu matriz debe admitir:
- Miembros privados: un puntero int** para los datos 2D, y miembros size_t para filas y columnas
- Un constructor que reciba filas y columnas, inicializando todos los elementos a 0
- Un destructor que libere adecuadamente toda la memoria asignada
- Un constructor de copia y un operador de asignación de copia (copia profunda con verificación de autoasignación)
- Getters getRows() y getCols() (ambos const)
- Un método set(row, col, value) para establecer elementos individuales
- Un método const get(row, col) 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 una función amiga (friend) para mostrar la matriz fila por fila, con los elementos separados por espacios y cada fila en una línea nueva
- Subíndice: [] que devuelva un puntero a una fila, permitiendo la sintaxis matrix[row][col] (proporciona versiones const y no const)
Para los operadores aritméticos, asume 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, 2 columnas cada uno), llénalos usando el método set() y luego 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 simples. Imprime true o false (en minúsculas) para los resultados de la comparación.

Por ejemplo, con las entradas 1 2 3 4 para la Matrix A y 5 6 7 8 para 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

Usa std::stoi() para la conversión de entrada. Recuerda implementar != en términos de == para mantener la consistencia de tus operadores. No olvides los protectores de inclusión (header guards) 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: Muestra la Matrix A
    // cout << "Matrix A:" << endl;
    // Usa el operador << para imprimir la matriz
    
    // TODO: Muestra la Matrix B
    // cout << "Matrix B:" << endl;
    // Usa el operador << para imprimir la matriz
    
    // TODO: Muestra A + B
    // cout << "A + B:" << endl;
    
    // TODO: Muestra A - B
    // cout << "A - B:" << endl;
    
    // TODO: Muestra los resultados de la comparación
    // cout << "A == B: " << (use ternary for true/false) << endl;
    // cout << "A != B: " << (use ternary for true/false) << endl;
    
    // TODO: Muestra los resultados del acceso por subíndice
    // cout << "A[0][0]: " << ... << endl;
    // cout << "A[1][1]: " << ... << endl;
    
    return 0;
}