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

Vários métodos podem ser usados para se de­ter­mi­nar o tamanho de um array em C. Nosso tutorial C array length apresenta os mais im­por­tan­tes deles, para que você consiga gerenciar os seus vetores di­na­mi­ca­mente 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 in­for­ma­ção é crucial para se acessar elementos es­pe­cí­fi­cos 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 de­ter­mi­nar o com­pri­mento 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()
• Arit­mé­tica de ponteiros
• Loops

sizeof()

O operador C sizeof() é um dos prin­ci­pais ope­ra­do­res da linguagem de pro­gra­ma­ção C. Seu objetivo é de­ter­mi­nar o tamanho de um tipo de dado ou de uma variável, em bytes, durante o tempo de com­pi­la­ção. O operador sizeof retorna re­sul­ta­dos size_t: um tipo inteiro e sem sinal, que re­pre­senta o res­pec­tivo tamanho em bytes. Ao aplicar a função sizeof() em C, também é possível calcular o com­pri­mento de um array.

Sintaxe de sizeof()

Para de­ter­mi­nar 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 com­pri­mento do array será ar­ma­ze­nado.
• 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, de­ter­mi­na­mos o tamanho do array myArray e de um único elemento deste array em bytes, por meio do sizeof(). Assim, cal­cu­la­mos o número de elementos dividindo os re­sul­ta­dos 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

Arit­mé­tica de ponteiros

A arit­mé­tica de ponteiros não consegue de­ter­mi­nar o tamanho de um array em C de forma direta, pois um ponteiro sozinho não contém as in­for­ma­ções ne­ces­sá­rias sobre o tamanho e o com­pri­mento do array associado. No entanto, é possível usar os endereços dos elementos de um array para se de­ter­mi­nar o com­pri­mento deste mesmo array.

Sintaxe da arit­mé­tica de ponteiros

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

• &arr: Re­pre­senta um ponteiro para um array de elementos.
• (&arr + 1): In­cre­menta o ponteiro para o array arr em 1. Como arr é um array, o ponteiro apontará para o próximo array con­se­cu­tivo do mesmo tipo.

Exemplo de arit­mé­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 re­sul­tante 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 é exe­cu­tando 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 de­ter­mi­na­ção de com­pri­mento é executado.

Exemplo de loop

No exemplo de código a seguir, o loop in­cre­menta o contador arrayLength para cada elemento per­cor­rido. 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