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 crear 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 completa que admite operaciones aritméticas, comparaciones, acceso a elementos y salida en flujos, todo mediante una sintaxis intuitiva de operadores.

Organizarás el código en dos archivos:

Matrix.h: Define una clase Matrix que gestiona una matriz 2D de enteros usando memoria dinámica. Tu matriz debe admitir:
- Miembros privados: un puntero int** para los datos 2D y miembros size_t para las filas y las columnas
- Un constructor que recibe las filas y las columnas e inicializa todos los elementos en 0. Asigna un arreglo de punteros a filas y, luego, cada fila: data = new int*[rows]; y data[r] = new int[cols]; para cada fila r
- Un destructor que libera correctamente toda la memoria asignada: primero delete[] para cada fila y, luego, delete[] data;
- Un constructor de copia y un operador de asignación por 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 const get(row, col) para obtener elementos
Implementa estos operadores:
- Aritméticos: + y - para sumar y restar 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 nueva línea
- Subíndice: [], que devuelve un puntero a una fila y permite la sintaxis matrix[row][col] (proporciona las 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 (cada uno de 2 filas y 2 columnas), rellénalos usando 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 comparación.

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

Recuerda implementar != en términos de == para que tus operadores sean coherentes. No olvides incluir protecciones contra inclusiones múltiples en tu archivo de encabezado.

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 y 2 columnas cada uno)
    
    // TODO: Rellena las matrices usando el método set()
    
    // TODO: Muestra Matrix A
    // cout << "Matrix A:" << endl;
    // Usa el operador << para imprimir la matriz
    
    // TODO: Muestra 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: " << (usa el operador ternario para true/false) << endl;
    // cout << "A != B: " << (usa el operador ternario para true/false) << endl;
    
    // TODO: Muestra los resultados del acceso mediante índices
    // cout << "A[0][0]: " << ... << endl;
    // cout << "A[1][1]: " << ... << endl;
    
    return 0;
}