Melhores formas de de­ter­mi­nar o com­pri­mento de uma matriz em C

Uti­li­zando vários métodos, é possível de­ter­mi­nar o com­pri­mento de um array em C. Isso facilita o ge­ren­ci­a­mento dinâmico dos arrays e permite responder a al­te­ra­ções no seu tamanho.

Com­pri­mento de uma matriz em C

O com­pri­mento de um array em C refere-se à quan­ti­dade de elementos que ele contém. Essa in­for­ma­ção é crucial para aceder a elementos es­pe­cí­fi­cos no array, percorrê-lo ou realizar ma­ni­pu­la­ções nele. Quando um array é declarado em C, a memória para os elementos do array é alocada de forma contínua na RAM. Em C, não existe uma função integrada direta para de­ter­mi­nar o com­pri­mento do array, portanto, você deve calculá-lo ma­nu­al­mente.

Os métodos mais comuns são:

• sizeof()
• Arit­mé­tica de ponteiros
• Loops

sizeof()

sizeof()um dos ope­ra­do­res em C. Ele determina o tamanho de um tipo de dado ou variável em bytes durante o tempo de com­pi­la­ção. O tipo de retorno do operador sizeof() é size_t, um tipo inteiro sem sinal que re­pre­senta o tamanho em bytes. Com a função sizeof() em C, também é possível calcular o com­pri­mento de uma matriz em C.

Sintaxe

Para de­ter­mi­nar a quan­ti­dade de elementos, deve dividir o tamanho total da matriz pelo tamanho de um único elemento.

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

• data_type: é o tipo de dados em que será ar­ma­ze­nado o com­pri­mento da matriz.
• array_name: indica o nome da matriz.
• sizeof(array_name): retorna o tamanho total da matriz em bytes.
• sizeof(array_name[index]): ao dividir o tamanho total da matriz pelo tamanho de um único elemento, obtém-se a quan­ti­dade de elementos na matriz.
• index: re­pre­senta o índice de um elemento na matriz.

Exemplo

Em seguida, de­ter­mi­na­mos com sizeof() o tamanho da matriz myArray e de um único elemento em bytes, o que nos permite calcular a quan­ti­dade de elementos através da divisão dos re­sul­ta­dos.

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; 
}

O resultado será:

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

O com­pri­mento de uma matriz não pode ser de­ter­mi­nado di­re­ta­mente usando a arit­mé­tica de ponteiros, pois um ponteiro por si só não contém in­for­ma­ções sobre o tamanho ou com­pri­mento da matriz associada. No entanto, você pode usar os endereços dos elementos da matriz para de­ter­mi­nar o com­pri­mento da matriz em C.

Sintaxe

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

• &arr: re­pre­senta um ponteiro para uma matriz de elementos.
• (&arr + 1): aqui, o ponteiro para a matriz arr é in­cre­men­tado em 1. Como arr é uma matriz, isso significa que o ponteiro aponta para a próxima matriz adjacente do mesmo tipo que arr.

Exemplo

A expressão *(&arr + 1) - arr calcula a diferença entre o ponteiro para o próximo array &arr + 1 e o ponteiro para o primeiro elemento do array original. Neste caso, o espaço de memória «próximo» é o final do array. A diferença re­sul­tante é igual à quan­ti­dade de elementos no array.

#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; 
}

Resultado:

Number of elements in the array: 5

Loops

Outro método para de­ter­mi­nar o com­pri­mento de um array em C é com um loop for. Ele percorre o array e conta quantos elementos ele contém. Para isso, o array deve ser declarado no mesmo escopo em que o código para de­ter­mi­nar o com­pri­mento é executado.

Exemplo

Neste caso, o loop aumenta o contador arrayLength para cada elemento per­cor­rido. A condição i < sizeof(arr) / sizeof(arr[0]) garante que o loop seja executado apenas enquanto houver elementos reais na matriz.

#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; 
}

Resultado:

Number of elements in the array: 8