Cómo encontrar el tamaño del array en C++

Para encontrar la longitud de un arreglo en C++, cuenta sus elementos. La técnica adecuada depende del tipo: usa sizeof para un arreglo integrado mientras siga dentro del ámbito donde se declaró, size() para std::array o std::vector, o std::size para una llamada genérica de la biblioteca estándar. Un bucle for basado en rango también permite contar los elementos de un rango que ya se puede recorrer.

Contar los elementos de un arreglo en C++ con un bucle for basado en rango

Un bucle for basado en rango recorre cada elemento de un arreglo u otro rango iterable. Incrementa un contador en cada iteración para contar los elementos:

#include <iostream>

int main() {
    int values[] = {10, 20, 30, 40, 50};
    int count = 0;

    for (int value : values) {
        (void)value;
        ++count;
    }

    std::cout << "Element count: " << count << '\n';
}

Esto cuenta los elementos del rango que proporciona values. No permite averiguar el tamaño de la asignación a la que apunta un puntero sin formato ni el de un almacenamiento asignado dinámicamente. En esos casos, guarda por separado el número de elementos o usa un contenedor que informe de su tamaño.

Obtener la longitud de un arreglo integrado con sizeof

Para un arreglo integrado que todavía sea un arreglo en el ámbito actual, divide su tamaño total en bytes por el tamaño en bytes de un elemento:

#include <iostream>
#include <cstddef>

int main() {
    int values[] = {1, 2, 3, 4, 5};
    const std::size_t count = sizeof(values) / sizeof(values[0]);

    std::cout << "Element count: " << count << '\n';
}

sizeof(values) devuelve el número de bytes que ocupa el arreglo completo, mientras que sizeof(values[0]) devuelve los bytes que ocupa un elemento. El cociente es el número de elementos. El ejemplo incluye <cstddef> para usar std::size_t.

Este cálculo deja de servir para contar elementos cuando se pasa un arreglo a una función. Un parámetro escrito como int values[] se ajusta a int* values; dentro de esa función, sizeof(values) mide el puntero, no el arreglo original. El cociente resultante depende del tamaño del puntero y de los elementos en cada implementación, así que no proporciona un conteo portable. Pasa el número de elementos por separado o acepta un contenedor.

Usar size() con std::array y std::vector

Tanto std::array como std::vector ofrecen una función miembro size() que devuelve el número de elementos. std::array representa un arreglo de tamaño fijo, mientras que un vector puede cambiar de tamaño al añadir o quitar elementos.

#include <array>
#include <iostream>
#include <vector>

int main() {
    std::array<int, 3> fixed{4, 8, 12};
    std::vector<int> resizable{5, 10, 15, 20};

    std::cout << "std::array: " << fixed.size() << '\n';
    std::cout << "std::vector: " << resizable.size() << '\n';
}

Usa la función miembro del contenedor que tengas. std::array::size() informa de su cantidad fija de elementos; std::vector::size() informa de cuántos elementos contiene actualmente el vector.

Obtener la longitud de un arreglo con std::end() y std::begin()

En un arreglo integrado, std::begin apunta al primer elemento y std::end apunta a una posición después del último. Al restar ambos punteros se obtiene el número de elementos que hay entre ellos. Incluye <iterator> para usar estas funciones.

#include <iostream>
#include <iterator>

int main() {
    int values[] = {2, 4, 6, 8};
    const auto count = std::end(values) - std::begin(values);

    std::cout << "Element count: " << count << '\n';
}

La resta es válida porque ambos punteros se refieren al mismo arreglo o a su posición posterior al último elemento. Es útil al trabajar con un arreglo integrado; para std::array o std::vector, la función miembro size() suele ser más clara.

Obtener el número de elementos con std::size()

std::size es una función de la biblioteca estándar que devuelve el número de elementos. Funciona con arreglos integrados y contenedores estándar como std::array y std::vector. Incluye <iterator> para usarla.

#include <array>
#include <iostream>
#include <iterator>
#include <vector>

int main() {
    int built_in[] = {3, 6, 9};
    std::array<int, 2> fixed{7, 14};
    std::vector<int> resizable{11, 22, 33, 44};

    std::cout << "Built-in array: " << std::size(built_in) << '\n';
    std::cout << "std::array: " << std::size(fixed) << '\n';
    std::cout << "std::vector: " << std::size(resizable) << '\n';
}

A diferencia de la función miembro size(), std::size(container) se invoca como una función libre. Ofrece una forma común de escribir la llamada para los arreglos y contenedores compatibles, aunque cada contenedor sigue teniendo disponible su propia función miembro size().

Elegir el método adecuado para el tipo de arreglo

• Para un arreglo integrado en el mismo ámbito donde se declaró, usa sizeof(array) / sizeof(array[0]) o std::size(array).
• Para std::array y std::vector, prefiere su función miembro size(). Usa std::size(container) si te resulta útil contar con una llamada común.
• Usa std::end(array) - std::begin(array) cuando la resta de iteradores encaje bien en el código.
• Usa un bucle for basado en rango si quieres contar los elementos de un rango iterable recorriéndolos.
• Para un puntero o un arreglo asignado dinámicamente, conserva el número de elementos por separado o usa un contenedor. El puntero por sí solo no contiene el número de elementos asignados.

La distinción clave es entre el tamaño del almacenamiento en bytes y el número de elementos. sizeof mide bytes; divide por el tamaño en bytes de un elemento solo mientras la expresión siga refiriéndose al arreglo integrado completo. Las funciones size() de los contenedores y la resta de iteradores devuelven directamente el número de elementos.