# Como criar e usar 2D arrays em C

Com arrays, você pode armazenar um conjunto de dados relacionados em C, sem a necessidade de criar várias variáveis. Geralmente, os arrays são unidimensionais, mas podem ser expandidos para quantas dimensões forem necessárias. Mostraremos como criar e utilizar arrays 2D em C de forma eficaz.

## Noções básicas sobre arrays em C

Para criar e dominar efetivamente arrays 2D em C, é importante primeiro entender alguns conceitos básicos sobre arrays na [linguagem de programação C](https://www.ionos.com/digitalguide/websites/web-development/c-programming-language/ "Linguagem de programação C"). Como em muitas outras linguagens, arrays são um **bloco de memória** onde múltiplos valores do mesmo tipo de dado podem ser armazenados. Dessa forma, é possível armazenar e agrupar múltiplos valores sob um único nome de variável. O tamanho do array deve ser conhecido no momento da compilação e não pode ser alterado posteriormente.

```c
int números1[15];
// Opcionalmente, os valores armazenados podem ser especificados no momento da criação:
int números2[5] = {1, 2, 3, 4, 5};
```

Neste exemplo, o tipo de dados a serem armazenados é especificado como de costume antes do nome da variável. Os colchetes indicam que essa variável não é um valor único, mas um array. O número inteiro entre os colchetes indica quantos elementos desse tipo de dado podem ser armazenados no array. O array `números1` é criado **não inicializado** no exemplo acima, o que significa que nenhum valor é escrito nos campos. Esses valores podem ser preenchidos posteriormente no código.

O array `números2`, por outro lado, é inicializado manualmente no momento da criação. Essa abordagem geralmente não é recomendada para arrays maiores, pois pode ser muito trabalhosa e resultar em um código menos legível. É preferível preencher os arrays **programaticamente**, por exemplo, usando um loop for.

```c
int numbers3[100]; 
for(int i = 0; i < 100; i++) { 
numbers3[i] = i + 1; 
}
// Cria um array que contenha os números inteiros de 1 a 100.
```

Nota Dependendo do sistema operacional em que você está trabalhando, do padrão C que está utilizando e de onde no seu programa você declarou uma variável não inicializada, essa variável pode conter um valor aleatório. Isso também se aplica aos campos de arrays. Portanto, é melhor não acessar campos de arrays que ainda não foram inicializados, especialmente se o valor armazenado neles for interpretado como um **ponteiro**.

Depois que um array é criado, é possível acessar valores individuais usando seu índice. Note que os arrays começam com índice 0. O exemplo a seguir ilustra isso:

```c
int números2[5] = {1, 2, 3, 4, 5};
números2[3] = números2[2];
printf("%d\n", números2[3]);
// Ausgabe: 3
```

Para criar um array 2D em C, você pode fazer sso declarando um array onde **cada elemento é outro array**. Isso permite organizar dados em duas dimensões, como uma grade, matriz ou tabela.

## Criar 2D array em C

2D arrays em C são simplesmente arrays unidimensionais onde cada elemento é outro array. Portanto, um array 2D pode ser entendido como uma **tabela ou matriz** de valores. 2D Arrays são criados e preenchidos com a seguinte sintaxe:

```c
ints_two_dimensions[10][10]; 
ints_two_dimensions[0][1] = 0; 
ints_two_dimensions[2][1] = 2; 
ints_two_dimensions[9][4] = 36; 
// etc.
```

Aqui, o número entre colchetes à esquerda representa o índice no primeiro array ao qual se deseja acessar, e o número à direita representa o índice no segundo array. Esses dois números podem ser imaginados como **coordenadas 2D ou números de linha e coluna**. Assim como os arrays unidimensionais, arrays bidimensionais também podem ser inicializados com valores no momento da criação.

```c
floats_two_dimensions[2][6] = { 
{0.1, 3.56, 6.346, 8.9, 45.345, 2.284}, 
{7.0, 1.12, 9.74, 0.0, 3.56, 4.4} 
}
```

O princípio de um array dentro de outro array não está limitado a duas dimensões. Com este método, você pode criar arrays com **quantas dimensões forem necessárias**.

```c
int ints_four_dimensions[10][10][10][10];
```

## Aplicar 2D arrays em C

### Iterar sobre array 2D

O caso de uso mais comum para arrays 2D em C (ou arrays multidimensionais) é a criação de estruturas de dados multidimensionais. No exemplo a seguir, um array 2D é preenchido alternadamente com zeros e uns para representar um tabuleiro de xadrez:

```c
#include <stdio.h>
#define ARRAY_LENGTH 8
int main() {
    int tabuleirodexadrez[8][8];
    for(int i = 0; i < ARRAY_LENGTH; i++) {
        for(int j = 0; j < ARRAY_LENGTH; j++) {
           tabuleirodexadrez[i][j] = (i + j) % 2;
            printf("%d", tabuleiro de xadrez[i][j]);
        }
        printf("\n");
    }
    return 0;
}
/*
Saída:
01010101
10101010
01010101
10101010
01010101
10101010
01010101
10101010
*/
```

### Array de strings

Um detalhe muito importante para o uso eficaz de arrays é o seguinte: um array é na verdade apenas um **ponteiro para uma posição na memória** e é interpretado como tal pelo compilador C. O índice usado para escrever ou ler campos individuais representa, portanto, **o deslocamento ao longo do array em relação ao endereço base**. O exemplo a seguir deve ilustrar isso:

```c
int números2[5] = {1, 2, 3, 4, 5};
printf("%d\n", *números2);
// Saída: 1
printf("%d\n", *(números2 + 2));
// Saída: 3
```

Strings são tratadas da mesma forma em C. Portanto, é possível **iterar sobre uma string como se fosse um array**. Isso pode ser visto no exemplo a seguir, onde três frases armazenadas em um array são exibidas caractere por caractere em maiúsculas. Para acessar os caracteres, é utilizado o índice do array (colchetes):

```c
#include <stdio.h>
int main() {
     char* frases[3];
    frases[0] = "Olá, esta é a primeira frase.\n";
    frases[1] = "Esta é apenas a segunda frase.\n";
    frases[2] = "Agora são três.\n";
     printf("Frases originais:\n\n");
     for(int i = 0; i < 3; i++) {
          printf("%s", frases[i]);
     }
     printf("\nFrases alteradas:\n\n");
     for(int i = 0; i < 3; i++) {
          int j = 0;
          while(frases[i][j] != '\n') {
                if(frases[i][j] >= 'a' && frases[i][j] <= 'z') {
                     printf("%c", frases[i][j] - 0x20);
                } else {
                     printf("%c", frases[i][j]);
                }
                j++;
          }
          printf("\n");
     }
}
/*
Saída:
Frases originais:
Olá, esta é a primeira frase.
Esta é apenas a segunda frase.
E agora são três.
Frases alteradas:
OLÁ, ESTA É A PRIMEIRA FRASE.
ESTA É APENAS A SEGUNDA FRASE.
E AGORA SÃO TRÊS.
*/
```


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/2d-arrays-em-c/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/2d-arrays-em-c/) for AI/LLM consumption.