Come trovo la lunghezza di un array?

C'è un modo per trovare quanti valori ha un array? Rilevare se ho raggiunto o meno la fine di un array funzionerebbe anche.

Se intendi un array in stile C, puoi fare qualcosa del tipo:

int a[7];
std::cout << "Length of array = " << (sizeof(a)/sizeof(*a)) << std::endl;

Questo non funziona sui puntatori (cioè non funzionerà per nessuno dei seguenti):

int *p = new int[7];
std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl;

o:

void func(int *p)
{
    std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl;
}

int a[7];
func(a);

In C ++, se si desidera questo tipo di comportamento, è necessario utilizzare una classe contenitore; probabilmente std::vector.

Come altri hanno già detto, puoi usare il sizeof(arr)/sizeof(*arr)ma questo ti darà la risposta sbagliata per i tipi di puntatore che non sono array.

template<class T, size_t N>
constexpr size_t size(T (&)[N]) { return N; }

Questo ha la bella proprietà di non riuscire a compilare per tipi non array (Visual Studio lo _countoffa). Ilconstexpr che rende questo un'espressione tempo di compilazione in modo che non ha nessun inconvenienti sopra il macro (almeno nessuno che io conosca).

Puoi anche considerare l'utilizzo std::arrayda C ++ 11 che espone la sua lunghezza senza sovraccarico su un array C nativo.

C ++ 17 ha std::size()nella <iterator>testata che fa lo stesso e funziona per contenitori STL troppo (grazie a @ Jon C ).

In questo sizeof( myArray )modo otterrai il numero totale di byte allocati per quell'array. È quindi possibile scoprire il numero di elementi nell'array dividendo per la dimensione di un elemento nell'array:sizeof( myArray[0] )

Sebbene questa sia una vecchia domanda, vale la pena aggiornare la risposta a C ++ 17. Nella libreria standard è ora presente la funzione modello std::size(), che restituisce il numero di elementi sia in un contenitore std che in un array in stile C. Per esempio:

#include <iterator>

uint32_t data[] = {10, 20, 30, 40};
auto dataSize = std::size(data);
// dataSize == 4

C'è un modo per trovare quanti valori ha un array?

Sì!

Provare sizeof(array)/sizeof(array[0])

Rilevare se ho raggiunto o meno la fine di un array funzionerebbe anche.

Non vedo alcun modo per questo a meno che il tuo array non sia un array di caratteri (es. Stringa).

PS: in C ++ usa sempre std::vector. Esistono diverse funzioni integrate e una funzionalità estesa.

std::vector ha un metodo size() che restituisce il numero di elementi nel vettore.

(Sì, questa è una risposta ironica)

#include <iostream>

int main ()
{
    using namespace std;
    int arr[] = {2, 7, 1, 111};
    auto array_length = end(arr) - begin(arr);
    cout << "Length of array: " << array_length << endl;
}

Dal C ++ 11, sono stati introdotti alcuni nuovi modelli per aiutare a ridurre il dolore quando si ha a che fare con la lunghezza dell'array. Tutti sono definiti nell'intestazione <type_traits>.

• std::rank<T>::value

  Se T è un tipo di array, fornisce il valore della costante membro pari al numero di dimensioni dell'array. Per qualsiasi altro tipo, il valore è 0.

• std::extent<T, N>::value

  Se Tè un tipo di array, fornisce il valore costante del membro uguale al numero di elementi lungo la Ndimensione dell'array, se Nè in [0, std::rank<T>::value). Per qualsiasi altro tipo, o se l' Tarray di sconosciuto è associato lungo la sua prima dimensione ed Nè 0, il valore è 0.

• std::remove_extent<T>::type

  Se Tè un array di qualche tipo X, fornisce il tipo typedef membro uguale a X, altrimenti type è T. Si noti che se si Ttratta di un array multidimensionale, viene rimossa solo la prima dimensione.

• std::remove_all_extents<T>::type

  Se Tè un array multidimensionale di qualche tipo X, fornisce il tipo typedef membro uguale a X, altrimenti il ​​tipo è T.

Per ottenere la lunghezza su qualsiasi dimensione di un array multidimensionale, si decltypepuò usare per combinare std::extent. Per esempio:

#include <iostream>
#include <type_traits> // std::remove_extent std::remove_all_extents std::rank std::extent

template<class T, size_t N>
constexpr size_t length(T(&)[N]) { return N; }

template<class T, size_t N>
constexpr size_t length2(T(&arr)[N]) { return sizeof(arr) / sizeof(*arr); }

int main()
{
    int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}};

    // New way
    constexpr auto l1 = std::extent<decltype(a)>::value;     // 5
    constexpr auto l2 = std::extent<decltype(a), 1>::value;  // 4
    constexpr auto l3 = std::extent<decltype(a), 2>::value;  // 3
    constexpr auto l4 = std::extent<decltype(a), 3>::value;  // 0

    // Mixed way
    constexpr auto la = length(a);
    //constexpr auto lpa = length(*a);  // compile error
    //auto lpa = length(*a);  // get at runtime
    std::remove_extent<decltype(a)>::type pa;  // get at compile time
    //std::remove_reference<decltype(*a)>::type pa;  // same as above
    constexpr auto lpa = length(pa);
    std::cout << la << ' ' << lpa << '\n';

    // Old way
    constexpr auto la2 = sizeof(a) / sizeof(*a);
    constexpr auto lpa2 = sizeof(*a) / sizeof(**a);
    std::cout << la2 << ' ' << lpa2 << '\n';

    return 0;
}

BTY, per ottenere il numero totale di elementi in un array multidimensionale:

constexpr auto l = sizeof(a) / sizeof(std::remove_all_extents<decltype(a)>::type);

O inseriscilo in un modello di funzione:

#include <iostream>
#include <type_traits>
    

template<class T>
constexpr size_t len(T &a)
{
    return sizeof(a) / sizeof(typename std::remove_all_extents<T>::type);
}

int main()
{
    int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}};
    constexpr auto ttt = len(a);
    int i;
    std::cout << ttt << ' ' << len(i) << '\n';
    
    return 0;
}

Altri esempi su come usarli possono essere trovati seguendo i link.

C'è anche il modo TR1 / C ++ 11 / C ++ 17 (vedi Live on Coliru):

const std::string s[3] = { "1"s, "2"s, "3"s };
constexpr auto n       = std::extent<   decltype(s) >::value; // From <type_traits>
constexpr auto n2      = std::extent_v< decltype(s) >;        // C++17 shorthand

const auto     a    = std::array{ "1"s, "2"s, "3"s };   // C++17 class template arg deduction -- http://en.cppreference.com/w/cpp/language/class_template_argument_deduction
constexpr auto size = std::tuple_size_v< decltype(a) >;

std::cout << n << " " << n2 << " " << size << "\n"; // Prints 3 3 3

Invece di utilizzare la funzione di array incorporata aka:

 int x[3] = {0, 1, 2};

dovresti usare la classe array e il modello array. Provare:

#include <array>
array<type_of_the_array, number_of_elements_in_the_array> Name_of_Array = {};

Quindi ora se vuoi trovare la lunghezza dell'array, tutto ciò che devi fare è usare la funzione size nella classe array.

Name_of_Array.size();

e ciò dovrebbe restituire la lunghezza degli elementi nell'array.

In C ++, usando la classe std :: array per dichiarare un array, si può facilmente trovare la dimensione di un array e anche l'ultimo elemento.

#include<iostream>
#include<array>
int main()
{
    std::array<int,3> arr;

    //To find the size of the array
    std::cout<<arr.size()<<std::endl;

    //Accessing the last element
    auto it=arr.end();
    std::cout<<arr.back()<<"\t"<<arr[arr.size()-1]<<"\t"<<*(--it);

    return 0;
}

In effetti, la classe array ha molte altre funzioni che ci permettono di usare l'array un contenitore standard.
Riferimento 1 a C ++ std :: array class
Riferimento 2 a std :: array class
Gli esempi nei riferimenti sono utili.

Questa è praticamente una domanda vecchia e leggendaria e ci sono già molte risposte sorprendenti là fuori. Ma con il tempo ci sono nuove funzionalità aggiunte alle lingue, quindi dobbiamo continuare ad aggiornare le cose secondo le nuove funzionalità disponibili.

Ho appena notato che nessuno ha ancora parlato di C ++ 20. Quindi ho pensato di scrivere una risposta.

C ++ 20

In C ++ 20, c'è un nuovo modo migliore aggiunto alla libreria standard per trovare la lunghezza dell'array, ad es std:ssize(). Questa funzione restituisce a signed value.

#include <iostream>

int main() {
    int arr[] = {1, 2, 3};
    std::cout << std::ssize(arr);
    return 0;
}

C ++ 17

In C ++ 17 c'era un modo migliore (in quel momento) per lo stesso che è std::size()definito in iterator.

#include <iostream>
#include <iterator> // required for std::size

int main(){
    int arr[] = {1, 2, 3};
    std::cout << "Size is " << std::size(arr);
    return 0;
}

PS Questo metodo funziona per vector .

Vecchio

Questo approccio tradizionale è già menzionato in molte altre risposte.

#include <iostream>

int main() {
    int array[] = { 1, 2, 3 };
    std::cout << sizeof(array) / sizeof(array[0]);
    return 0;
}

Cordiali saluti, se ti chiedi perché questo approccio non funziona quando l'array viene passato a un'altra funzione . Il motivo è,

Un array non viene passato per valore in C ++, ma viene passato il puntatore all'array. Come in alcuni casi, il passaggio dell'intero array può essere un'operazione costosa. È possibile verificare ciò passando l'array a una funzione e apportare alcune modifiche all'array lì, quindi stampare nuovamente l'array in main. Otterrai risultati aggiornati.

E come già sapresti, il sizeof() funzione fornisce il numero di byte, quindi in un'altra funzione restituirà il numero di byte allocati per il puntatore anziché l'intero array. Quindi questo approccio non funziona.

Ma sono sicuro che puoi trovare un buon modo per farlo, secondo le tue esigenze.

Happy Coding.

Hai un sacco di opzioni da usare per ottenere una dimensione dell'array C.

int myArray [] = {0, 1, 2, 3, 4, 5, 7};

1) sizeof(<array>) / sizeof(<type>):

std::cout << "Size:" << sizeof(myArray) / sizeof(int) << std::endl;

2) sizeof(<array>) / sizeof(*<array>):

std::cout << "Size:" << sizeof(myArray) / sizeof(*myArray) << std::endl;

3) sizeof(<array>) / sizeof(<array>[<element>]):

std::cout << "Size:" << sizeof(myArray) / sizeof(myArray[0]) << std::endl;

Ecco un'implementazione di ArraySizeda Google Protobuf .

#define GOOGLE_ARRAYSIZE(a) \
  ((sizeof(a) / sizeof(*(a))) / static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

// test codes...
char* ptr[] = { "you", "are", "here" };
int testarr[] = {1, 2, 3, 4};
cout << GOOGLE_ARRAYSIZE(testarr) << endl;
cout << GOOGLE_ARRAYSIZE(ptr) << endl;

ARRAYSIZE (arr) funziona controllando sizeof (arr) (il numero di byte nell'array) e sizeof (* (arr)) (il # di byte in un elemento dell'array). Se il primo è divisibile per il secondo, forse arr è davvero un array, nel qual caso il risultato della divisione è il numero di elementi dell'array. Altrimenti, arr non può essere un array e generiamo un errore del compilatore per impedire la compilazione del codice.

Poiché la dimensione di bool è definita dall'implementazione, dobbiamo eseguire il cast! (Sizeof (a) & sizeof (* (a))) in size_t per assicurarci che il risultato finale abbia tipo size_t.

Questa macro non è perfetta in quanto accetta erroneamente determinati puntatori, vale a dire dove la dimensione del puntatore è divisibile per la dimensione della punta. Poiché tutto il nostro codice deve passare attraverso un compilatore a 32 bit, in cui un puntatore è di 4 byte, ciò significa che tutti i puntatori a un tipo la cui dimensione è 3 o maggiore di 4 verranno (giustamente) rifiutati.

Per C ++ / CX (durante la scrittura di app UWP usando C ++ in Visual Studio) possiamo trovare il numero di valori in un array semplicemente usando la size()funzione.

Codice sorgente:

string myArray[] = { "Example1", "Example2", "Example3", "Example4" };
int size_of_array=size(myArray);

Se coutil size_of_arrayl'uscita sarà:

>>> 4

sizeof(array_name)fornisce le dimensioni dell'intero array e sizeof(int)fornisce le dimensioni del tipo di dati di ogni elemento dell'array.

Quindi, dividendo la dimensione dell'intero array per la dimensione di un singolo elemento dell'array si ottiene la lunghezza dell'array.

 int array_name[] = {1, 2, 3, 4, 5, 6};
 int length = sizeof(array_name)/sizeof(int);

RISPOSTA :

int number_of_elements = sizeof(array)/sizeof(array[0])

SPIEGAZIONE :

Poiché il compilatore imposta una porzione di memoria di dimensioni specifiche da parte per ciascun tipo di dati e un array è semplicemente un gruppo di quelli, è sufficiente dividere la dimensione dell'array per la dimensione del tipo di dati. Se ho un array di 30 stringhe, il mio sistema mette da parte 24 byte per ogni elemento (stringa) dell'array. Con 30 elementi, questo è un totale di 720 byte. 720/24 == 30 elementi. L'algoritmo piccolo e preciso per questo è:

int number_of_elements = sizeof(array)/sizeof(array[0]) che equivale a

number_of_elements = 720/24

Si noti che non è necessario conoscere il tipo di dati dell'array, anche se si tratta di un tipo di dati personalizzato.

Solo un pensiero, ma ho appena deciso di creare una variabile contatore e memorizzare la dimensione dell'array in posizione [0]. Ho eliminato la maggior parte del codice che avevo nella funzione ma vedrai dopo essere uscito dal loop, a prime [0] viene assegnato il valore finale di 'a'. Ho provato ad usare i vettori ma VS Express 2013 non mi è piaciuto molto. Nota anche che 'a' inizia da uno per evitare la sovrascrittura [0] ed è inizializzato all'inizio per evitare errori. Non sono un esperto, ho pensato di condividere.

int prime[] = {0};
int primes(int x, int y){
    using namespace std; int a = 1;
    for (int i = x; i <= y; i++){prime[a] = i; a++; }
    prime[0] = a; return 0;
}

Una buona soluzione che utilizza generici:

template <typename T,unsigned S>
inline unsigned arraysize(const T (&v)[S]) { return S; }

Quindi chiama semplicemente arraysize(_Array); per ottenere la lunghezza dell'array.

fonte

Per il vecchio compilatore g ++, puoi farlo

template <class T, size_t N>
char (&helper(T (&)[N]))[N];

#define arraysize(array) (sizeof(helper(array)))

int main() {
    int a[10];
    std::cout << arraysize(a) << std::endl;
    return 0;
}

Fornisco una soluzione complicata qui:

Puoi sempre memorizzare lengthnel primo elemento:

// malloc/new

arr[0] = length;
arr++;

// do anything. 
int len = *(arr-1);

free(--arr); 

Il costo è necessario --arrquando si invocafree

puoi trovare la lunghezza di un array seguendo:

int  arr[] = {1, 2, 3, 4, 5, 6}; 
int size = *(&arr + 1) - arr; 
cout << "Number of elements in arr[] is "<< size; 
return 0;

Puoi semplicemente usare questo frammento:

#include <iostream>
#include <string>
#include <array>

using namespace std;

int main()
{

  array<int,3> values;
  cout << "No. elements in valuea array: " << values.size() << " elements." << endl;
  cout << "sizeof(myints): " << sizeof(values) << endl;

}

ed ecco il riferimento: http://www.cplusplus.com/reference/array/array/size/

Evitare di utilizzare il tipo insieme a sizeof, poiché sizeof(array)/sizeof(char)improvvisamente si corrompe se si modifica il tipo di array.

In Visual Studio, hai l'equivalente se sizeof(array)/sizeof(*array). Puoi semplicemente digitare_countof(array)

Personalmente suggerirei (se non si è in grado di lavorare con funzioni specializzate per qualsiasi motivo) di espandere prima la compatibilità del tipo di array oltre ciò che normalmente si userebbe come (se si memorizzassero valori ≥ 0:

unsigned int x[] -> int x[]

di quanto renderebbe l'array 1 elemento più grande di quanto sia necessario per renderlo. Per l'ultimo elemento inseriresti un tipo incluso nello specificatore di tipo espanso ma che normalmente non utilizzeresti, ad esempio usando l'esempio precedente l'ultimo elemento sarebbe -1. Ciò consente (utilizzando un ciclo for) di trovare l'ultimo elemento di un array.

Uno dei motivi più comuni per cui potresti finire per cercarlo è perché vuoi passare un array a una funzione e non devi passare un altro argomento per le sue dimensioni. In genere si desidera inoltre che la dimensione dell'array sia dinamica. Quell'array potrebbe contenere oggetti, non primitivi, e gli oggetti potrebbero essere complessi in modo tale che size_of () sia un'opzione non sicura per il calcolo del conteggio.

Come altri hanno suggerito, prendere in considerazione l'uso di uno std :: vector o di una lista, ecc. Invece di un array primitivo. Sui vecchi compilatori, tuttavia, non avresti ancora la soluzione finale che probabilmente vorresti facendo semplicemente questo, perché il popolamento del contenitore richiede un sacco di brutte righe push_back (). Se sei come me, vuoi una soluzione a linea singola con oggetti anonimi coinvolti.

Se si utilizza un'alternativa contenitore STL a un array primitivo, questo post SO può essere utile per i modi per inizializzarlo: qual è il modo più semplice per inizializzare uno std :: vector con elementi hardcoded?

Ecco un metodo che sto usando per questo che funzionerà universalmente su compilatori e piattaforme:

Crea una struttura o classe come contenitore per la tua raccolta di oggetti. Definire una funzione di sovraccarico dell'operatore per <<.

class MyObject;

struct MyObjectList
{
    std::list<MyObject> objects;
    MyObjectList& operator<<( const MyObject o )
    { 
        objects.push_back( o );
        return *this; 
    }
};

Puoi creare funzioni che prendono la tua struct come parametro, ad es .:

someFunc( MyObjectList &objects );

Quindi, puoi chiamare quella funzione, in questo modo:

someFunc( MyObjectList() << MyObject(1) <<  MyObject(2) <<  MyObject(3) );

In questo modo, puoi costruire e passare una raccolta di oggetti di dimensioni dinamiche a una funzione in un'unica linea pulita!

Diciamo che hai un array globale dichiarato nella parte superiore della pagina

int global[] = { 1, 2, 3, 4 };

Per scoprire quanti elementi ci sono (in c ++) nell'array digitare il codice seguente:

sizeof(global) / 4;

La dimensione di (NAME_OF_ARRAY) / 4 ti restituirà il numero di elementi per il nome dell'array specificato.