Mejores formas de de­te­r­mi­nar la longitud de un array en C

Uti­li­za­n­do varios métodos, puedes de­te­r­mi­nar la longitud de un array en C. Esto facilita la gestión dinámica de los arrays y permite responder a cambios en su tamaño.

Longitud de un array en C

La longitud de un array en C se refiere a la cantidad de elementos que contiene. Esta in­fo­r­ma­ción es crucial para acceder a elementos es­pe­cí­fi­cos en el array, re­co­rre­r­lo o realizar ma­ni­pu­la­cio­nes en él. Cuando se declara un array en C, la memoria para los elementos del array se asigna de manera continua en la RAM. En C no hay una función integrada directa para de­te­r­mi­nar la longitud del array, por lo tanto, debes ca­l­cu­lar­la ma­nua­l­me­n­te.

Los métodos más ha­bi­tua­les son:

• sizeof()
• Ari­t­mé­ti­ca de punteros
• Bucles

sizeof()

sizeof()es uno de los ope­ra­do­res en C. Determina el tamaño de un tipo de dato o una variable en bytes durante el tiempo de co­m­pi­la­ción. El tipo de retorno del operador sizeof() es size_t, un tipo entero sin signo que re­pre­se­n­ta el tamaño en bytes. Con la función sizeof() en C, también puedes calcular la longitud de un array en C.

Sintaxis

Para de­te­r­mi­nar la cantidad de elementos, debes dividir el tamaño total del array por el tamaño de un solo elemento.

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

• data_type: es el tipo de dato en el que se al­ma­ce­na­rá la longitud del array.
• array_name: indica el nombre del array.
• sizeof(array_name): devuelve el tamaño total del array en bytes.
• sizeof(array_name[index]): al dividir el tamaño total del array por el tamaño de un solo elemento, obtienes la cantidad de elementos en el array.
• index: re­pre­se­n­ta el índice de un elemento en el array.

Ejemplo

A co­n­ti­nua­ción, de­te­r­mi­na­mos con sizeof() el tamaño del array myArray y de un solo elemento en bytes, lo que nos permite luego calcular la cantidad de elementos mediante la división de los re­su­l­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; 
}

El resultado será:

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

Ari­t­mé­ti­ca de punteros

La longitud de un array no puede de­te­r­mi­nar­se di­re­c­ta­me­n­te uti­li­za­n­do la ari­t­mé­ti­ca de punteros, ya que un puntero por sí solo no contiene in­fo­r­ma­ción sobre el tamaño o la longitud del array asociado. Sin embargo, puedes utilizar las di­re­c­cio­nes de los elementos del array para de­te­r­mi­nar la longitud del array en C.

Sintaxis

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

• &arr: re­pre­se­n­ta un puntero a un array de elementos.
• (&arr + 1): aquí, el puntero al array arr se in­cre­me­n­ta en 1. Dado que arr es un array, esto significa que el puntero apunta al siguiente array adyacente del mismo tipo que arr.

Ejemplo

La expresión *(&arr + 1) - arr calcula la di­fe­re­n­cia entre el puntero al próximo array &arr + 1 y el puntero al primer elemento del array original. En este caso, el “próximo” espacio de memoria es el final del array. La di­fe­re­n­cia re­su­l­ta­n­te es igual a la cantidad de elementos en el 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

Bucles

Otro método para de­te­r­mi­nar la longitud de un array en C es con un bucle for. Este recorre el array y cuenta cuántos elementos contiene. Para ello, el array debe ser declarado en el mismo ámbito (scope) donde se ejecuta el código para de­te­r­mi­nar la longitud.

Ejemplo

En este caso, el bucle aumenta el contador arrayLength por cada elemento recorrido. La condición i < sizeof(arr) / sizeof(arr[0]) garantiza que el bucle se ejecute solo mientras haya elementos reales en el 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; 
}

Resultado:

Number of elements in the array: 8