Introducción

Hoy veremos cómo obtener la longitud de un arreglo en C.

C es un lenguaje un poco antiguo, fue uno de los primeros lenguajes que nos enseñaron a la mayoría de nosotros. Antes de él existían otros lenguajes como B, Ada, y todos esos.

C en cambio es un lenguaje casi de bajo nivel y fácil de aprender.

Debido a que C no es un lenguaje muy nuevo, muchas funciones que necesitamos no vienen por defecto. Una de ellas es alguna función para obtener la longitud de un arreglo.

Obtener longitud de un arreglo en C

Para obtener la longitud de un arreglo en C usamos el operador unario sizeof. Este operador devuelve el tamaño (en bytes) que determinada variable ocupa. Con este operador y algunas divisiones podremos obtener la longitud de un arreglo en C.

Si quieres la solución rápida y sin explicación aquí está:

int longitud = sizeof(tuArreglo) / sizeof(tuArreglo[0]);

Si quieres saber más, continúa leyendo.

Primero: longitud de una variable

Veamos un ejemplo con una variable de tipo double. Esta variable utiliza 8 bytes de memoria, cosa que podemos comprobar con esto:

#include <stdio.h>

int main(int argc, char const *argv[])
{
 double miVariable = 666;
 int tamanio = sizeof(miVariable);
 printf("La variable de tipo double ocupa %d bytes\n", tamanio);
 return 0;
}

La salida será:

La variable de tipo double ocupa 8 bytes

Con eso obtenemos el tamaño de una variable. Ahora veamos otra cosa muy interesante.

Segundo: longitud de un arreglo

Cuando llamamos a sizeof y le pasamos un arreglo, devolverá la memoria (en bytes) que ocupa todo el arreglo.

Ojo: devuelve el tamaño del arreglo (los bytes que ocupa), no su longitud.

Es decir, si le pasamos un arreglo de longitud 2 que guarda doubles, devolverá 16; ya que cada double ocupa 8 bytes y si hay 2 entonces 2 x 8 = 16.

Eso puede demostrarse con el siguiente código:

#include <stdio.h>

int main(int argc, char const *argv[])
{
 double arreglo[2] = {123, 456};
 int tamanio = sizeof(arreglo);
 printf("El arreglo ocupa %d bytes\n", tamanio);
 return 0;
}

Cuya salida es:

El arreglo ocupa 16 bytes

Entonces con esto ya podemos hacernos una idea de cómo sacar la longitud de un arreglo.

Tercero: longitud de un arreglo en C, ahora sí

Con lo aprendido arriba podemos usar este operador para sacar la longitud de cualquier array.

Si sizeof devuelve el tamaño en bytes de un arreglo (en los ejemplos era 16 porque tenía 2 doubles)

Y a su vez devuelve el tamaño en bytes de una variable (en los ejemplos era 8 porque era double)

Podemos dividir el tamaño de todo el arreglo entre el tamaño del primer valor del mismo. Así:

#include <stdio.h>

int main(int argc, char const *argv[])
{
 double arreglo[2] = {123, 456};

 // Memoria ocupada por todo el arreglo
 int tamanioDelArreglo = sizeof(arreglo);

 // Memoria ocupada por su primer elemento
 int tamanioDeLaPrimeraVariableDelArreglo = sizeof(arreglo[0]);

 // División simple
 int longitud = tamanioDelArreglo / tamanioDeLaPrimeraVariableDelArreglo;
 printf( "El arreglo ocupa %d bytes.\n"
   "La primer variable ocupa %d bytes.\n"
   "Entonces la longitud es: %d", 
   tamanioDelArreglo, tamanioDeLaPrimeraVariableDelArreglo, longitud);
 return 0;
}

Al ejecutar ese programa esta es la salida:

El arreglo ocupa 16 bytes.
La primer variable ocupa 8 bytes.
Entonces la longitud es: 2

Este fragmento de código sirve para cualquier arreglo. Aquí está modificado para un array de enteros:

#include <stdio.h>

int main(int argc, char const *argv[])
{
 int arreglo[] = {1, 5, 20, 5, 15};

 // Memoria ocupada por todo el arreglo
 int tamanioDelArreglo = sizeof(arreglo);

 // Memoria ocupada por su primer elemento
 int tamanioDeLaPrimeraVariableDelArreglo = sizeof(arreglo[0]);

 // División simple
 int longitud = tamanioDelArreglo / tamanioDeLaPrimeraVariableDelArreglo;
 printf( "El arreglo ocupa %d bytes.\n"
   "La primer variable ocupa %d bytes.\n"
   "Entonces la longitud es: %d", 
   tamanioDelArreglo, tamanioDeLaPrimeraVariableDelArreglo, longitud);
 return 0;
}

Como un entero ocupa 4 bytes, el arreglo medirá 20 bytes. Y al dividir, da 5. La salida es esta:

El arreglo ocupa 20 bytes.
La primer variable ocupa 4 bytes.
Entonces la longitud es: 5

Conclusión

Por cierto, el operador sizeof es procesado en tiempo de compilación (como los macros) y no en tiempo de ejecución. Esto quiere decir que su uso no afecta al rendimiento de nuestro programa.