# 2D array em C++: Como criar e aplicar matriz bidimensional

Arrays 2D em C++ são usados para organizar dados no formato semelhante ao de uma tabela. No campo da matemática, especialmente na álgebra linear, arrays 2D oferecem a estrutura ideal para representar **matrizes**.

## O que é 2D array em C++?

Um 2D array em C++ é uma estrutura de dados utilizada para armazenar elementos em um **arranjo tabular bidimensional**. Ao contrário dos arrays unidimensionais, que contêm apenas uma linha de elementos, um array 2D organiza os dados em linhas e colunas. Os elementos em um array bidimensional são definidos por suas posições, especificadas por índices de linha e coluna. Essa estrutura facilita o acesso e a manipulação de pontos de dados individuais. Os arrays 2D têm diversas aplicações, desde cálculos matemáticos com matrizes até a gestão de dados em formato de grade.

## Sintaxe de 2D array em C++

Na linguagem C++, a sintaxe para a declaração de um array 2D é composta pelos seguintes elementos:

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

- **`data_type`**: O tipo de dados especifica que tipo de dados serão armazenados nas células do array 2D. Pode ser `int` para números inteiros, `double` para números de ponto flutuante, ou tipos de dados personalizados.
- **`arrayName`**: O nome funciona como um identificador que permite acessar todo o array.
- **`num_rows`**: Esta parte da sintaxe indica quantas linhas o array 2D terá.
- **`num_cols`**: Aqui você define o número de colunas para cada linha no array 2D.

No exemplo abaixo, estamos definindo um array 2D chamado `matrix` com 3 linhas e 4 colunas, totalizando 12 elementos.

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

### Gerar 2D array em C++

Podemos gerar um 2D array em C++ usando 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] << " ";` exibe cada elemento. Após cada linha, adicionamos `std::cout << std::endl;` para formatar melhor a saída.

```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;
}
```

Na saída, os elementos do array 2D são exibidos linha por linha:

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

## Exemplos de aplicação de 2D array em C++

Quando você está aprendendo a linguagem de programação [C++](https://www.ionos.com/digitalguide/websites/web-development/learn-c/ "Aprenda a programar em C"), eventualmente você trabalhará com arrays. Abaixo, mostramos a você aplicações típicas para arrays 2D em C++.

### 2D array em C++ como entrada do usuário

Aqui está um exemplo simples em C++ onde não definimos um array 2D com valores fixos, mas sim o tratamos como entrada do usuário. Neste caso, solicitamos ao usuário que insira o número de linhas e colunas, seguido pelos elementos reais do array:

```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 o usuário fornecer 2 linhas, 3 colunas e os valores `1, 2, 3, 4, 5, 6` como entrada, o array 2D seria o seguinte:

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

### Adição de matriz com 2D arrays em C++

Usando [operadores em C](https://www.ionos.com/digitalguide/websites/web-development/c-operators/ "Operadores em C"), como `+`, podemos facilmente adicionar matrizes com 2D arrays 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 sua soma é calculada e exibida na matriz resultante. A função `matrixAddition` recebe as duas matrizes de entrada e a matriz resultante como argumentos e realiza a adição. A função `displayMatrix` gera a soma das matrizes no console.

Obteremos como saída:

```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-br/digitalguide/sites-de-internet/desenvolvimento-web/2d-array-em-c-mais-mais/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/2d-array-em-c-mais-mais/) for AI/LLM consumption.