Mejores formas de determinar la longitud de un array en C

Equipo editorial de IONOS10.12.20244 mins

Utilizando varios métodos, puedes determinar 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 información es crucial para acceder a elementos específicos en el array, recorrerlo o realizar manipulaciones 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 determinar la longitud del array, por lo tanto, debes calcularla manualmente.

Los métodos más habituales son:

sizeof()
Aritmética de punteros
Bucles

`sizeof()`

sizeof()es uno de los operadores en C. Determina el tamaño de un tipo de dato o una variable en bytes durante el tiempo de compilación. El tipo de retorno del operador sizeof() es size_t, un tipo entero sin signo que representa 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 determinar 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 almacenará 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: representa el índice de un elemento en el array.

Ejemplo

A continuación, determinamos 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 resultados.

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

Aritmética de punteros

La longitud de un array no puede determinarse directamente utilizando la aritmética de punteros, ya que un puntero por sí solo no contiene información sobre el tamaño o la longitud del array asociado. Sin embargo, puedes utilizar las direcciones de los elementos del array para determinar la longitud del array en C.

Sintaxis

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

&arr: representa un puntero a un array de elementos.
(&arr + 1): aquí, el puntero al array arr se incrementa 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 diferencia 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 diferencia resultante 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 determinar 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 determinar 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: