Trova la dimensione dell'array in C++

Per trovare la lunghezza di un array in C++, conta i suoi elementi. La tecnica più adatta dipende dal tipo: usa sizeof per un array incorporato, finché si trova nell’ambito in cui è stato dichiarato; usa size() con std::array o std::vector, oppure std::size per una chiamata generica della libreria standard. Un ciclo for basato su intervallo può contare gli elementi di un intervallo che è già possibile iterare.

Conta gli elementi di un array in C++ con un ciclo for basato su intervallo

Un ciclo for basato su intervallo visita ogni elemento di un array o di un altro intervallo iterabile. Incrementa un contatore a ogni visita per contare gli elementi:

#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';
}

Questo conta gli elementi dell’intervallo fornito da values. Non determina la dimensione dell’allocazione di un puntatore grezzo o di memoria allocata dinamicamente; in questi casi, conserva separatamente il numero di elementi oppure usa un contenitore che ne restituisca la dimensione.

Trova la lunghezza di un array incorporato con sizeof

Per un array incorporato che nell’ambito corrente è ancora un array, dividi la dimensione totale in byte per la dimensione in byte di un singolo 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) restituisce il numero di byte occupati dall’intero array, mentre sizeof(values[0]) restituisce i byte occupati da un elemento. Il quoziente corrisponde al numero di elementi. L’esempio include <cstddef> per usare std::size_t.

Questo calcolo non consente più di ricavare il numero di elementi dopo aver passato un array a una funzione. Un parametro dichiarato come int values[] viene adattato a int* values; all’interno della funzione, sizeof(values) misura il puntatore, non l’array originale. Il quoziente risultante dipende dalle dimensioni, specifiche dell’implementazione, del puntatore e degli elementi, quindi non fornisce un conteggio portabile. Passa il conteggio separatamente oppure accetta un contenitore.

Usa size() con std::array e std::vector

Sia std::array sia std::vector mettono a disposizione una funzione membro size() che restituisce il numero di elementi. std::array rappresenta un array di dimensione fissa, mentre un vector può cambiare dimensione quando si aggiungono o si rimuovono elementi.

#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 funzione membro del contenitore che hai. std::array::size() restituisce il numero fisso di elementi; std::vector::size() restituisce il numero corrente di elementi del vector.

Trova la lunghezza di un array con std::end() e std::begin()

Per un array incorporato, std::begin punta al primo elemento e std::end alla posizione immediatamente successiva all’ultimo. Sottraendo i due puntatori si ottiene il numero di elementi compresi tra loro. Per queste funzioni, includi <iterator>.

#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 sottrazione è valida perché entrambi i puntatori si riferiscono allo stesso array, oppure alla posizione immediatamente successiva alla sua fine. Questo approccio è utile con un array incorporato; per std::array o std::vector, la funzione membro size() è in genere più chiara.

Ottieni il numero di elementi con std::size()

std::size è una funzione della libreria standard che restituisce il numero di elementi. Si applica agli array incorporati e a contenitori standard come std::array e std::vector. Per usarla, includi <iterator>.

#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 differenza della funzione membro size(), std::size(container) è una chiamata a una funzione non membro. Offre una forma comune per i tipi di array e contenitori supportati, mentre resta disponibile anche la funzione membro size() di ciascun contenitore.

Scegli il metodo giusto in base al tipo di array

• Per un array incorporato, nello stesso ambito in cui è stato dichiarato, usa sizeof(array) / sizeof(array[0]) oppure std::size(array).
• Per std::array e std::vector, preferisci la funzione membro size(). Usa std::size(container) se ti è utile una chiamata comune.
• Usa std::end(array) - std::begin(array) quando la sottrazione degli iteratori si adatta al codice circostante.
• Usa un ciclo for basato su intervallo se vuoi contare gli elementi visitandoli.
• Per un puntatore o un array allocato dinamicamente, conserva separatamente il conteggio oppure usa un contenitore. Il puntatore, da solo, non contiene il numero di elementi allocati.

La distinzione fondamentale è tra la dimensione in byte della memoria occupata e il numero di elementi. sizeof misura i byte; dividili per la dimensione in byte di un elemento soltanto finché l’espressione si riferisce ancora all’intero array incorporato. Le funzioni size() dei contenitori e la sottrazione degli iteratori restituiscono direttamente il numero di elementi.