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 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:

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:

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:

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

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:

#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:

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.

#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:

Number of elements in the array: 8