# Como criar e utilizar matrizes bidimensionais (two dimensional array) em C++

Uma matriz bidimensional em C++ é utilizada para organizar os dados em forma de tabela. Em áreas matemáticas, especialmente em álgebra linear, as matrizes bidimensionais oferecem uma estrutura ideal para a visualização de **matrizes**.

## O que é exatamente uma matriz 2D em C++?

Uma matriz bidimensional em C++ é uma estrutura de dados para armazenar elementos numa **disposição bidimensional semelhante a uma tabela**. Ao contrário das matrizes unidimensionais, que contêm apenas uma série de elementos, uma matriz bidimensional organiza os dados em linhas e colunas. Os elementos de uma matriz bidimensional são definidos pelas suas posições, que são especificadas por índices de linha e coluna. Esta estrutura facilita o acesso e a manipulação de pontos de dados individuais. As matrizes bidimensionais têm múltiplas aplicações, desde cálculos matemáticos com matrizes até à gestão de dados em formato raster.

## É assim que se estrutura uma matriz bidimensional em C++.

Em C++, a sintaxe para a declaração de uma matriz bidimensional consiste nos seguintes elementos:

```c++
data_type arrayName[num_rows][num_cols];
```

- **`data_type`**: O tipo de dados especifica que tipo de dados devem ser armazenados nas células da matriz bidimensional. Isso pode ser, por exemplo, `int` para números inteiros, `double` para números de ponto flutuante ou até mesmo tipos de dados personalizados.
- **`arrayName`**: O nome funciona como um identificador através do qual se pode aceder a toda a matriz.
- **`num_rows`**: Este fragmento da sintaxe indica quantas linhas a matriz bidimensional deve ter.
- **`num_cols`**: Aqui é especificada a quantidade de colunas para cada linha na matriz bidimensional.

No exemplo a seguir, definimos uma matriz bidimensional chamada `matrix` com 2 linhas e 4 colunas, o que equivale a um total de 12 elementos.

```c++
int matrix[3][4] = {{1, 2, 3, 4}, 
    {5, 6, 7, 8}, 
    {9, 10, 11, 12}};
```

### Criar uma matriz bidimensional em C++

Podemos criar uma matriz bidimensional utilizando um **loop for**. O loop externo itera sobre as linhas, enquanto o loop interno percorre as colunas de cada linha. A instrução `std::cout << matrix[i][j] << " ";` mostra cada elemento. Após cada linha, geramos uma nova linha com `std::cout << std::endl;` para formatar melhor o resultado.

```c++
#include <iostream> 
 
int main() { 
 
    int matrix[3][4] = {{1, 2, 3, 4}, 
                        {5, 6, 7, 8}, 
                        {9, 10, 11, 12}}; 
 
    for (int i = 0; i < 3; ++i) { 
 
        for (int j = 0; j < 4; ++j) { 
            std::cout << matrix[i][j] << " "; 
        } 
  
        std::cout << std::endl; 
    } 
 
    return 0; 
}
```

No resultado, os elementos da matriz bidimensional são representados linha por linha:

```c++
1 2 3 4 
5 6 7 8 
9 10 11 12
```

## Exemplos de aplicação para matrizes bidimensionais em C++

Se aprender C++, eventualmente irá trabalhar com matrizes. A seguir, mostramos exemplos típicos de aplicações para matrizes bidimensionais em C++.

### Matriz bidimensional em C++ como entrada do utilizador

Aqui está um exemplo simples em C++ em que não definimos uma matriz bidimensional com valores fixos, mas sim a processamos como entrada do utilizador. Neste caso, pedimos ao utilizador para introduzir o número de linhas e colunas, seguido dos elementos reais da matriz:

```c++
#include <iostream> 
 
int main() { 
 
    int numRows, numCols; 
    std::cout << "Number of rows: "; 
    std::cin >> numRows; 
    std::cout << "Number of columns: "; 
    std::cin >> numCols; 
 
    int userArray[numRows][numCols]; 
 
    std::cout << "Please enter in elements:\n"; 
    for (int i = 0; i < numRows; ++i) { 
        for (int j = 0; j < numCols; ++j) { 
            std::cout << "Element [" << i << "][" << j << "]: "; 
            std::cin >> userArray[i][j]; 
        } 
    } 
 
    std::cout << "2D array:\n"; 
    for (int i = 0; i < numRows; ++i) { 
        for (int j = 0; j < numCols; ++j) { 
            std::cout << userArray[i][j] << " "; 
        } 
        std::cout << std::endl; 
    } 
 
    return 0; 
}
```

Se forem passadas `2` linhas e `3` colunas e os valores `1, 2, 3, 4, 5, 6` como entrada do utilizador, então a matriz bidimensional será:

```c++
2D array: 
1 2 3 
4 5 6
```

### Soma de matrizes com matrizes bidimensionais

Usando operadores C como `+`, podemos somar facilmente matrizes com matrizes bidimensionais em C++.

```c++
#include <iostream> 
 
const int numRows = 2;  
const int numCols = 2;  
 
void matrixAddition(int A[][numCols], int B[][numCols], int result[][numCols]) { 
    for (int i = 0; i < numRows; ++i) { 
        for (int j = 0; j < numCols; ++j) { 
            result[i][j] = A[i][j] + B[i][j]; 
        } 
    } 
} 
 
void displayMatrix(int matrix[][numCols]) { 
    for (int i = 0; i < numRows; ++i) { 
        for (int j = 0; j < numCols; ++j) { 
            std::cout << matrix[i][j] << " "; 
        } 
        std::cout << std::endl; 
    } 
} 
 
int main() { 
    int matrixA[numRows][numCols] = {{1, 2}, {3, 4}}; 
    int matrixB[numRows][numCols] = {{5, 6}, {7, 8}}; 
    int resultMatrix[numRows][numCols]; 
 
    matrixAddition(matrixA, matrixB, resultMatrix); 
 
    // Output of matrix A and B and their sum 
    std::cout << "Matrix A:\n"; 
    displayMatrix(matrixA); 
 
    std::cout << "\nMatrix B:\n"; 
    displayMatrix(matrixB); 
 
    std::cout << "\nSum (A + B):\n"; 
    displayMatrix(resultMatrix); 
 
    return 0; 
}
```

Primeiro, criamos as matrizes `2x2`, `A` e `B`, e a sua soma é calculada e apresentada na matriz resultante. A função `matrixAddition` recebe as duas matrizes iniciais e a matriz resultante como argumentos e realiza a soma. A função `displayMatrix` apresenta a soma das matrizes na consola.

Obtemos este resultado:

```c++
Matrix A: 
1 2 
3 4 
 
Matrix B: 
5 6 
7 8 
 
Sum (A + B): 
6 8 
10 12
```


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/matrizes-bidimensionais-matriz-2d-em-c-plus-plus/](https://www.ionos.com/pt-pt/digitalguide/paginas-web/desenvolvimento-web/matrizes-bidimensionais-matriz-2d-em-c-plus-plus/) for AI/LLM consumption.