Recapitulação - Classe Matrix

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy — lição 47 de 104.

Desafio

Fácil

Vamos construir uma classe Matrix que reúne todas as técnicas de sobrecarga de operadores que você aprendeu neste capítulo. Você criará uma matriz completa que suporta operações aritméticas, comparações, acesso a elementos e saída de fluxo — tudo por meio de uma sintaxe de operador intuitiva.

Você organizará seu código em dois arquivos:

Matrix.h: Defina uma classe Matrix que gerencia um array 2D de inteiros usando memória dinâmica. Sua matriz deve suportar:
- Membros privados: um ponteiro int** para os dados 2D e membros size_t para linhas e colunas
- Um construtor que recebe linhas e colunas, inicializando todos os elementos como 0
- Um destrutor que libera adequadamente toda a memória alocada
- Um construtor de cópia e um operador de atribuição por cópia (cópia profunda com verificação de autoatribuição)
- Getters getRows() e getCols() (ambos const)
- Um método set(row, col, value) para definir elementos individuais
- Um método const get(row, col) para recuperar elementos
Implemente estes operadores:
- Aritméticos: + e - para adição e subtração de matrizes (retornam uma nova Matrix por valor)
- Comparação: == e != para verificar se duas matrizes têm as mesmas dimensões e elementos idênticos
- Fluxo: << como uma função amiga (friend) para exibir a matriz linha por linha, com elementos separados por espaços e cada linha em uma nova linha
- Subscrito: [] que retorna um ponteiro para uma linha, permitindo a sintaxe matrix[row][col] (forneça as versões const e não-const)
Para os operadores aritméticos, assuma que ambas as matrizes têm as mesmas dimensões. Os operadores de comparação devem retornar false se as dimensões forem diferentes.
main.cpp: Leia a entrada para criar e manipular duas matrizes 2x2. O formato de entrada é:
1. Quatro inteiros para a primeira matriz (linha por linha): a00, a01, a10, a11
2. Quatro inteiros para a segunda matriz (linha por linha): b00, b01, b10, b11
Crie dois objetos Matrix (2 linhas, 2 colunas cada), preencha-os usando o método set() e, em seguida, demonstre seus operadores:

Formato de saída:
```
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 linha deve exibir os elementos separados por espaços simples. Imprima true ou false (minúsculo) para os resultados de comparação.

Por exemplo, com as entradas 1 2 3 4 para a Matriz A e 5 6 7 8 para a 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

Use std::stoi() para a conversão de entrada. Lembre-se de implementar != em termos de == para manter seus operadores consistentes. Não se esqueça dos header guards em seu arquivo de cabeçalho.

Experimente você mesmo

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

using namespace std;

int main() {
    // Lê a entrada para a primeira matriz (2x2): a00, a01, a10, a11
    int a00, a01, a10, a11;
    cin >> a00 >> a01 >> a10 >> a11;
    
    // Lê a entrada para a segunda matriz (2x2): b00, b01, b10, b11
    int b00, b01, b10, b11;
    cin >> b00 >> b01 >> b10 >> b11;
    
    // TODO: Criar dois objetos Matrix (2 linhas, 2 colunas cada)
    
    // TODO: Preencher as matrizes usando o método set()
    
    // TODO: Exibir a Matrix A
    // cout << "Matrix A:" << endl;
    // Use o operador << para imprimir a matriz
    
    // TODO: Exibir a Matrix B
    // cout << "Matrix B:" << endl;
    // Use o operador << para imprimir a matriz
    
    // TODO: Exibir A + B
    // cout << "A + B:" << endl;
    
    // TODO: Exibir A - B
    // cout << "A - B:" << endl;
    
    // TODO: Exibir os resultados da comparação
    // cout << "A == B: " << (use ternário para true/false) << endl;
    // cout << "A != B: " << (use ternário para true/false) << endl;
    
    // TODO: Exibir os resultados do acesso por índice
    // cout << "A[0][0]: " << ... << endl;
    // cout << "A[1][1]: " << ... << endl;
    
    return 0;
}