# Matrizes 2D em C

As matrizes permitem armazenar um conjunto de dados relacionados em C sem ter de criar várias variáveis. Como regra geral, as matrizes são unidimensionais, mas podem ser expandidas para qualquer número de dimensões. Mostramos-lhe como criar matrizes 2D em C e como utilizá-las de forma eficaz.

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

Para poder criar e dominar eficazmente as matrizes 2D em C, primeiro deve saber algumas coisas básicas sobre as matrizes na linguagem de programação C. Como em muitas outras linguagens, as matrizes são um **bloco de memória** no qual podem ser armazenados vários valores do mesmo tipo de dados. Isto permite guardar e resumir vários valores sob o mesmo nome de variável. O tamanho da matriz deve ser conhecido no momento da compilação e não pode ser modificado posteriormente. O bloco de código a seguir mostra como criar matrizes em C:

```c
int cifras1[15]; 
// Opcionalmente, los valores almacenados pueden ser especificados al crear el array: 
int cifras2[5] = {1, 2, 3, 4, 5};
```

Neste exemplo, o tipo de dados a ser guardado é especificado, como de costume, antes do nome da variável. Os colchetes indicam que esta variável não é um valor único, mas sim uma matriz. O número inteiro entre colchetes indica quantos elementos deste tipo de dados podem ser armazenados na matriz. No exemplo anterior, a matriz `cifras1` é criada **sem inicialização**, o que significa que não são escritos valores nos campos. Estes podem ser preenchidos com valores mais adiante no código.

A matriz `cifras2`, por outro lado, é inicializada manualmente quando criada. Essa abordagem não é recomendável na maioria dos casos, pois consome muito tempo para matrizes grandes e o código resultante é frequentemente ilegível. Portanto, é melhor tentar preencher as matrizes **programaticamente**, por exemplo, com um loop for:

```c
cifras2[100]; 
for(int i = 0; i < 100; i++) { 
cifras2[i] = i + 1; 
} 
// Crea un array que contiene los números enteros del 1 al 100.
```

Nota Dependendo do sistema operativo em que estiver a trabalhar, do padrão C que estiver a utilizar e do local do seu programa em que declarou uma variável não inicializada, essa variável pode conter um valor aleatório. O mesmo ocorre com os campos de matriz. Portanto, é melhor não aceder a campos que ainda não tenha inicializado, especialmente se o valor armazenado neles deve ser interpretado como um **ponteiro**.

Depois de criar uma matriz, o índice pode ser usado para aceder a valores individuais. Tenha em atenção que as matrizes começam com o índice 0. O exemplo seguinte serve para ilustrar isso:

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

Uma matriz 2D pode ser criada em C criando uma matriz em que **cada campo contenha outra matriz**. Continue a ler para saber mais.

## Como criar uma matriz 2D em C

As matrizes 2D em C nada mais são do que matrizes unidimensionais cujos campos contêm cada um outra matriz. Portanto, uma matriz 2D pode ser entendida como uma **tabela ou matriz** de valores. As matrizes 2D podem ser criadas e preenchidas com a seguinte sintaxe:

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

Aqui, o número entre colchetes à esquerda representa o índice da primeira matriz a ser acedida e o número à direita representa o índice da segunda. Estes dois números podem ser visualizados como **coordenadas bidimensionais ou números de linha ou coluna**. Tal como as matrizes unidimensionais, as matrizes bidimensionais também podem ser inicializadas com valores quando são criadas.

```c
2d_floats[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 uma matriz dentro de outra matriz não se limita a duas dimensões. Pode utilizar este método para criar matrizes com **qualquer número de dimensões**.

```c
int 4d_ints[10][10][10][10]
```

## Casos práticos de matrizes 2D em C

### Iterar sobre um array 2D

A aplicação mais comum das matrizes 2D em C (ou matrizes multidimensionais) é a criação de estruturas de dados multidimensionais. No exemplo a seguir, uma matriz bidimensional é preenchida alternadamente com zeros e uns para representar um tabuleiro de xadrez:

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

### Matriz de strings

Um detalhe muito importante para o uso habilidoso de matrizes: uma matriz é, na verdade, apenas um **ponteiro para uma posição na memória**, e o compilador C entende-a como tal. O índice especificado ao escrever ou ler campos individuais representa, portanto, **o deslocamento ao longo da matriz em relação ao endereço base**. O exemplo a seguir ilustra isso:

```c
int cifras2[5] = {1, 2, 3, 4, 5}; 
printf("%d\n", *cifras2); 
// Resultado: 1 
printf("%d\n", *(cifras2 + 2)); 
// Resultado: 3
```

As strings ou cadeias são tratadas da mesma forma em C. Portanto, é possível iterar **sobre uma cadeia como se fosse uma matriz**. Isso pode ser visto no exemplo a seguir, em que três registos armazenados numa matriz são exibidos caractere por caractere em maiúsculas. Para aceder aos caracteres, utiliza-se o campo índice da matriz (colchetes):

```c
#include <stdio.h> 
 
int main() { 
    char* frase[3]; 
    frase[0] = "¡Hola! Esta es la primera frase.\n"; 
    frase[1] = "Esta es la segunda frase.\n"; 
    frase[2] = "Y esta, la tercera.\n"; 
    printf("Frases originales:\n\n"); 
    for(int i = 0; i < 3; i++) { 
        printf("%s", frases[i]); 
    } 
    printf("\nFrases cambiadas:\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"); 
    } 
} 
/* 
Resultado: 
Frases originales: 
 
¡Hola! Esta es la primera frase. 
Esta es la segunda frase. 
Y esta, la tercera. 
 
Frases cambiadas: 
 
¡HOLA! ESTA ES LA PRIMERA FRASE. 
ESTA ES LA SEGUNDA FRASE. 
Y ESTA, LA TERCERA. 
*/
```


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