How to get the number of elements of an Array in Arduino

Para obtener el número de elementos en un array de Arduino, usa sizeof(array) / sizeof(array[0]). El operador sizeof() devuelve el total de bytes que el array ocupa en memoria, y al dividir por el tamaño en bytes de un solo elemento se obtiene la cantidad de elementos.

Es común usar arrays como parte del código que subimos a Arduino. Puedes haber declarado un array sin definir explícitamente su tamaño, llenándolo directamente:

int pinesDigitales[] = {2, 3, 4, 5, 6};

En algún momento, querrás iterar sobre cada elemento usando un bucle for. Eso significa que necesitas saber el número total de elementos:

for (int i = 0; i < totalPines; i++) {
  // aplicar lógica a pinesDigitales[i]
}

Tu primer instinto podría ser usar sizeof() directamente:

int pinesDigitales[] = {2, 3, 4, 5, 6};
int totalPines = sizeof(pinesDigitales);  // ¡Devuelve 10, no 5!

for (int i = 0; i < totalPines; i++) {
  // ¡Esto se saldrá de los límites!
}

Esto no funciona correctamente porque sizeof() devuelve bytes, no el número de elementos. En este artículo, cubriremos la fórmula correcta, explicaremos por qué funciona, mostraremos cómo manejar arrays 2D y discutiremos errores comunes a evitar.

Cómo Obtener el Número de Elementos en un Array de Arduino

Arduino usa C++, y la fórmula para obtener la longitud del array en C++ es dividir el tamaño total en bytes del array por el tamaño en bytes de un solo elemento:

Longitud del array = sizeof(array) / sizeof(array[0])

Aplicando esto a nuestro ejemplo:

int pinesDigitales[] = {2, 3, 4, 5, 6};
int totalPines = sizeof(pinesDigitales) / sizeof(pinesDigitales[0]);
// totalPines = 10 / 2 = 5

for (int i = 0; i < totalPines; i++) {
  // aplicar lógica a pinesDigitales[i]
}

Esto funciona porque:

• sizeof(pinesDigitales) devuelve 10 bytes (5 elementos × 2 bytes por int en Arduino Uno)
• sizeof(pinesDigitales[0]) devuelve 2 bytes (el tamaño de un int)
• 10 / 2 = 5 elementos

Cómo Funciona sizeof() en Arduino

El operador sizeof() está integrado en C/C++ y devuelve cuántos bytes ocupa una variable, tipo de dato o array en memoria. Se evalúa en tiempo de compilación, no en tiempo de ejecución, por lo que no añade sobrecarga a tu programa.

sizeof() con Diferentes Tipos de Datos

Diferentes tipos de datos usan diferentes cantidades de bytes. Los tamaños exactos dependen de la placa que estés usando:

Esto importa para los cálculos de longitud de arrays. La misma fórmula funciona en todas las placas, pero los conteos de bytes serán diferentes. Por ejemplo, un array de int con 5 elementos usa 10 bytes en un Uno pero 20 bytes en un ESP32. La fórmula maneja esto automáticamente porque tanto el numerador como el denominador escalan juntos.

Obtener el Tamaño de un Array 2D en Arduino

El mismo principio se extiende a arrays multidimensionales. Para un array 2D (una matriz), puedes calcular tanto el número de filas como el número de columnas:

int matriz[3][4] = {
  {1, 2, 3, 4},
  {5, 6, 7, 8},
  {9, 10, 11, 12}
};

int filas = sizeof(matriz) / sizeof(matriz[0]);         // 3
int columnas = sizeof(matriz[0]) / sizeof(matriz[0][0]); // 4
int totalElementos = filas * columnas;                    // 12

Errores Comunes con sizeof() en Arduino

Error 1: Usar sizeof() Dentro de una Función

Este es el error más común y peligroso. Cuando pasas un array a una función, C++ lo convierte en un puntero. La función recibe la dirección de memoria, no el array real. Por lo que sizeof() dentro de la función devuelve el tamaño del puntero (2 bytes en Uno, 4 bytes en ESP32) — no el tamaño del array.

// ❌ INCORRECTO — sizeof() devuelve tamaño del puntero
void imprimirArray(int arr[]) {
  int len = sizeof(arr) / sizeof(arr[0]);  // ¡Devuelve 1 en Uno!
  for (int i = 0; i < len; i++) {
    Serial.println(arr[i]);
  }
}

// ✅ CORRECTO — pasar la longitud como parámetro
void imprimirArray(int arr[], int len) {
  for (int i = 0; i < len; i++) {
    Serial.println(arr[i]);
  }
}

void setup() {
  Serial.begin(9600);
  int miArray[] = {10, 20, 30, 40, 50};
  int longitudArray = sizeof(miArray) / sizeof(miArray[0]);
  imprimirArray(miArray, longitudArray);
}

void loop() {}

Regla general: siempre calcula la longitud del array antes de pasarlo a una función, y luego pasa la longitud como un parámetro extra.

Error 2: Olvidar Dividir por el Tamaño del Elemento

// ❌ INCORRECTO
int totalPines = sizeof(pinesDigitales);  // Devuelve bytes, no elementos

// ✅ CORRECTO
int totalPines = sizeof(pinesDigitales) / sizeof(pinesDigitales[0]);

Error 3: Asumir que Todas las Placas Usan los Mismos Tamaños de Bytes

El código que funciona en un Arduino Uno puede comportarse diferente en un ESP32 o Arduino Due porque int es de 2 bytes en placas AVR pero de 4 bytes en placas de 32 bits. La fórmula de división con sizeof() maneja esto automáticamente, pero si codificas los tamaños de bytes directamente (como dividir por 2 en vez de sizeof(arr[0])), tu código fallará en diferentes placas.

Por Qué Arduino C++ No Tiene una Función de Longitud de Array

Si has trabajado con otros lenguajes de programación como JavaScript, Python o Java, estás acostumbrado a obtener la longitud del array con una propiedad o método simple. C/C++ estándar no proporciona esto debido a cómo fueron diseñados estos lenguajes. C fue creado en una época cuando las computadoras tenían memoria muy limitada. Almacenar metadatos como la longitud del array junto a cada array costaría memoria extra — memoria que los sistemas embebidos como Arduino no pueden permitirse desperdiciar.

Mejor Práctica: Definir el Tamaño del Array en una Variable

La forma más simple de evitar el cálculo con sizeof() es definir el tamaño del array en una variable o constante separada antes de declarar el array:

const int NUM_PINES = 5;
int pinesDigitales[NUM_PINES] = {2, 3, 4, 5, 6};

for (int i = 0; i < NUM_PINES; i++) {
  pinMode(pinesDigitales[i], OUTPUT);
}

Crear una Macro ARRAY_LENGTH Reutilizable

#define ARRAY_LENGTH(arr) (sizeof(arr) / sizeof(arr[0]))

int pinesDigitales[] = {2, 3, 4, 5, 6};

void setup() {
  Serial.begin(9600);
  Serial.println(ARRAY_LENGTH(pinesDigitales));  // 5
}

void loop() {}

Importante: esta macro tiene la misma limitación de descomposición de puntero que sizeof() sin procesar. No funcionará correctamente dentro de una función que reciba el array como parámetro.

Ejemplo Práctico: Parpadear Múltiples LEDs

int pinesLed[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
int totalPines = sizeof(pinesLed) / sizeof(pinesLed[0]);

void setup() {
  for (int i = 0; i < totalPines; i++) {
    pinMode(pinesLed[i], OUTPUT);
  }
}

void loop() {
  for (int i = 0; i < totalPines; i++) {
    digitalWrite(pinesLed[i], HIGH);
    delay(1000);
    digitalWrite(pinesLed[i], LOW);
    delay(1000);
  }
}

Observa cómo totalPines se calcula una vez al inicio usando la fórmula de sizeof(). Si agregas un nuevo pin al array pinesLed, el resto del código se adapta automáticamente — no necesitas actualizar un número codificado.

Resumen

En Arduino (C++), no existe una propiedad .length() integrada para arrays. Para obtener el número de elementos, usa:

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

Puntos clave para recordar:

• sizeof() devuelve bytes, no elementos
• Siempre divide por sizeof(array[0]), no por un número codificado
• La fórmula no funciona dentro de funciones que reciben el array como parámetro (descomposición de puntero)
• Para arrays 2D, usa el mismo enfoque para obtener filas y columnas por separado
• Cuando sea posible, define el tamaño del array como una variable const para mayor claridad