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 criar 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 oferece suporte a operações aritméticas, comparações, acesso a elementos e saída em fluxo — tudo por meio de uma sintaxe intuitiva de operadores.

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

Matrix.h: Defina uma classe Matrix que gerencie uma matriz 2D de inteiros usando memória dinâmica. Sua matriz deve oferecer suporte a:
- Membros privados: um ponteiro int** para os dados 2D e membros size_t para linhas e colunas
- Um construtor que receba linhas e colunas, inicializando todos os elementos como 0
- Um destrutor que libere corretamente 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 get(row, col) const para obter 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 friend para exibir a matriz linha por linha, com os elementos separados por espaços e cada linha em uma nova linha
- Índice: [], que retorna um ponteiro para uma linha, permitindo a sintaxe matrix[row][col] (forneça versões const e não const)
Para os operadores aritméticos, suponha que ambas as matrizes tenham 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 da 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 e 2 colunas cada), preencha-os usando o método set() e, em seguida, demonstre seus operadores:

Formato da 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 (em letras minúsculas) para os resultados das comparações.

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

Use std::stoi() para a conversão da entrada. Lembre-se de implementar != com base em == para manter seus operadores consistentes. Não se esqueça dos protetores de inclusão no arquivo de cabeçalho.

Experimente você mesmo

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

using namespace std;

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