# C array length: Descobrir o tamanho de um array em c

Vários métodos podem ser usados para se determinar o **tamanho de um array em C**. Nosso tutorial C array length apresenta os mais importantes deles, para que você consiga gerenciar os seus vetores dinamicamente e reagir a mudanças no código de forma eficaz.

## Tamanho de array em C

Quando alguém fala no tamanho de um array (vetor) em C, a pessoa se refere ao **número de elementos** que ele contém. A informação é crucial para se acessar elementos específicos de arrays, percorrê-los e manipulá-los. Quando um array em C é declarado, a memória para os elementos deste array é alocada de forma contínua na memória RAM. Isso quer dizer que, em C, não existe uma função própria e direta para se determinar o comprimento de vetores. Assim, para descobri-lo, você deve executar o cálculo manual desse valor.

Os métodos mais comuns para se calcular o tamanho de um array em C incluem:

- **sizeof()**
- **Aritmética de ponteiros**
- **Loops**

## `sizeof()`

O [operador C](https://www.ionos.com/digitalguide/websites/web-development/c-operators/ "Operadores em C") `sizeof()` é um dos principais operadores da linguagem de programação C. Seu objetivo é determinar o **tamanho de um tipo de dado ou de uma variável, em bytes,** durante o tempo de compilação. O operador `sizeof` retorna resultados `size_t`: um tipo inteiro e sem sinal, que representa o respectivo tamanho em bytes. Ao aplicar a função `sizeof()` em C, também é possível calcular o comprimento de um array.

### Sintaxe de sizeof()

Para determinar o número de elementos de um vetor em C, você deve dividir o tamanho total deste vetor pelo tamanho de um único elemento nele contido, como mostra a estrutura a seguir:

```c
data_type arrayLength = sizeof(array_name) / sizeof(array_name[index]);
```

- **`data_type`**: Tipo de dado no qual o comprimento do array será armazenado.
- **`array_name`**: Indica o nome do array.
- **`sizeof(array_name)`**: Expressão que retorna o tamanho total do array em bytes.
- **`sizeof(array_name[index])`**: Expressão que divide o tamanho total do array pelo tamanho de um único elemento, para se obter o número de elementos do array.
- **`index`**: Índice de um elemento no array.

### Exemplo de aplicação de sizeof()

No exemplo abaixo, determinamos o tamanho do array `myArray` e de um único elemento deste array em bytes, por meio do `sizeof()`. Assim, calculamos o número de elementos **dividindo os resultados obtidos**. Observe:

```c
int main() {
    int myArray[] = {1, 2, 3, 4, 5};
    size_t totalSize = sizeof(myArray);
    size_t elementSize = sizeof(myArray[0]);
    size_t arrayLength = totalSize / elementSize;
    printf("Total size of the array: %d bytes\n", (int)totalSize);
    printf("Size of a single element: %d bytes\n", (int)elementSize);
    printf("Number of elements in the array: %d\n", (int)arrayLength);
    return 0;
}
```

Este é o resultado obtido pelo código:

```c
Total size of the array: 20 bytes
Size of a single element: 4 bytes
Number of elements in the array: 5
```

## Aritmética de ponteiros

A aritmética de ponteiros não consegue determinar o tamanho de um array em C de forma direta, pois um ponteiro sozinho não contém as informações necessárias sobre o tamanho e o comprimento do array associado. No entanto, é possível usar os **endereços dos elementos de um array** para se determinar o comprimento deste mesmo array.

### Sintaxe da aritmética de ponteiros

```c
data_type arr_length = *(&arr + 1) - arr;
```

- **`&arr`**: Representa um ponteiro para um array de elementos.
- **`(&arr + 1)`**: Incrementa o ponteiro para o array `arr` em 1. Como `arr` é um array, o ponteiro apontará para o próximo array consecutivo do mesmo tipo.

### Exemplo de aritmética de ponteiros

A expressão `*(&arr + 1) - arr` calcula a diferença entre o ponteiro e o próximo array `&arr + 1`, assim como o ponteiro para o primeiro elemento do array original. Nesse caso, a próxima área de memória é o fim do array. A diferença resultante será igual ao número de elementos do array, como ilustra o exemplo de código abaixo:

```c
#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int length = *(&arr + 1) - arr;
    printf("Number of elements in the array: %d\n", length);
    return 0;
}
```

Este é o resultado obtido pelo código:

```c
Number of elements in the array: 5
```

## Loops

Outra maneira de se descobrir o tamanho de um vetor em C é executando um **loop for**. Este loop percorre o array e conta quantos elementos ele contém. Para isso, o array deve ser declarado no mesmo escopo no qual o código de determinação de comprimento é executado.

### Exemplo de loop

No exemplo de código a seguir, o loop incrementa o contador `arrayLength` para cada elemento percorrido. A condição `i < sizeof(arr) / sizeof(arr[0])` garante que o loop só seja executado enquanto houver elementos no array.

```c
#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
    size_t arrayLength = 0;
    for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
        arrayLength++;
    }
    printf("Number of elements in the array: %d\n", arrayLength);
    return 0;
}
```

Este é o resultado obtido pelo código:

```c
Number of elements in the array: 8
```


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