Come trovo la lunghezza di un array?

C’è un modo per trovare quanti valori ha un array? Funzionerebbe anche il rilevamento se ho raggiunto o meno la fine di un array.

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; 

Tuttavia, ciò non funziona sui puntatori, vale a dire che non funzionerà per nessuno dei seguenti motivi:

 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 vuoi questo tipo di comportamento, dovresti usare una class contenitore; probabilmente std::vector .

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

 template constexpr size_t size(T (&)[N]) { return N; } 

Questo ha la bella proprietà di non riuscire a compilare per tipi di array diversi (visual studio ha _countof che fa questo). Il constexpr rende un’espressione del tempo di compilazione in modo che non abbia alcun svantaggio sulla macro (almeno nessuno che conosca).

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

C ++ 17 ha std::size() nell’intestazione che fa lo stesso e funziona anche per i container STL (grazie a @Jon C ).

Facendo sizeof( myArray ) otterrai il numero totale di byte allocati per quella matrice. È quindi ansible scoprire il numero di elementi nell’array dividendo per la dimensione di un elemento nell’array: sizeof( myArray[0] )

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

Sì!

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

Funzionerebbe anche il rilevamento se ho raggiunto o meno la fine di un array.

Non vedo alcun modo per questo a meno che l’array non sia un array di caratteri (cioè una stringa).

PS: In C ++ usa sempre std::vector . Ci sono diverse funzioni integrate e una funzionalità estesa.

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

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

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

(Sì, questa è una risposta ironica)

 #include  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 momento che C ++ 11, alcuni nuovi modelli sono introdotti per aiutare a ridurre il dolore quando si tratta di lunghezza dell’array. Tutti sono definiti nell’intestazione .

  • std::rank::value

    Se T è un tipo di matrice, fornisce il valore costante del membro uguale al numero di dimensioni dell’array. Per qualsiasi altro tipo, il valore è 0.

  • std::extent::value

    Se T è un tipo di matrice, fornisce al membro un valore costante uguale al numero di elementi lungo la N dimensione dell’array, se N è in [0, std::rank::value ). Per qualsiasi altro tipo, o se T è una matrice di limite sconosciuto lungo la sua prima dimensione e N è 0, il valore è 0.

  • std::remove_extent::type

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

  • std::remove_all_extents::type

    Se T è una matrice multidimensionale di qualche tipo X , fornisce al membro un tipo typedef uguale a X , altrimenti il ​​tipo è T

Per ottenere la lunghezza su qualsiasi dimensione di una matrice multidimensionale, è ansible utilizzare decltype da combinare con std::extent . Per esempio:

 #include  #include  // std::remove_extent std::remove_all_extents std::rank std::extent template constexpr size_t length(T(&)[N]) { return N; } template 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::value; // 5 constexpr auto l2 = std::extent::value; // 4 constexpr auto l3 = std::extent::value; // 3 constexpr auto l4 = std::extent::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::type pa; // get at compile time //std::remove_reference::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 multidimentale:

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

O inseriscilo in un modello di funzione:

 #include  #include  template constexpr size_t len(T &a) { return sizeof(a) / sizeof(typename std::remove_all_extents::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 di come usarli potrebbero essere trovati seguendo i collegamenti.

C’è anche il modo TR1 / C ++ 11 / C ++ 17 (vederlo dal vivo su Coliru ):

 const std::string s[3] = { "1"s, "2"s, "3"s }; constexpr auto n = std::extent< decltype(s) >::value; // From  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 usare la funzione di array incorporata alias:

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

dovresti usare la class dell’array e il modello dell’array. Provare:

 #include  array Name_of_Array = {}; 

quindi ora se vuoi trovare la lunghezza dell’array tutto ciò che devi fare usa la funzione dimensione nella class dell’array.

 Name_of_Array.size(); 

e che dovrebbe restituire la lunghezza degli elementi nella matrice.

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

 #include #include int main() { std::array arr; //To find the size of the array std::cout< 

In effetti, la class dell'array ha un sacco di altre funzioni che ci permettono di usare array come container standard.
Riferimento 1 alla class C ++ std :: array
Riferimento 2 alla class std :: array
Gli esempi nei riferimenti sono utili.

Ecco un’implementazione di ArraySize da Google Protobuf .

 #define GOOGLE_ARRAYSIZE(a) \ ((sizeof(a) / sizeof(*(a))) / static_cast(!(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 analizzando sizeof (arr) (il numero di byte nell'array) e sizeof (* (arr)) (il numero di byte in un elemento dell'array). Se il primo è divisibile da quest'ultimo, forse arr è effettivamente un array, nel qual caso il risultato della divisione è il numero di elementi dell'array. In caso contrario, arr non può essere una matrice e generiamo un errore del compilatore per impedire la compilazione del codice.

Poiché la dimensione di bool è definita dall'implementazione, è necessario eseguire il cast! (Sizeof (a) e sizeof (* (a))) in size_t per garantire che il risultato finale abbia type size_t.

Questa macro non è perfetta in quanto accetta erroneamente determinati puntatori, vale a dire dove la dimensione del puntatore è divisibile per la dimensione del punto d'impatto. Poiché tutto il nostro codice deve passare attraverso un compilatore a 32 bit, in cui un puntatore è di 4 byte, questo significa che tutti i puntatori a un tipo le cui dimensioni sono 3 o maggiori di 4 verranno rifiutati (correttamente).

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

Codice sorgente:

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

Se si cout il size_of_array l’output sarà:

 >>> 4 

Una buona soluzione che utilizza i farmaci generici:

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

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

fonte

  length = sizeof(array_name)/sizeof(int); 

Solo un pensiero, ma ho appena deciso di creare una variabile contatore e memorizzare la dimensione dell’array in posizione [0]. Ho cancellato la maggior parte del codice che avevo nella funzione ma vedrai dopo aver chiuso il ciclo, a primo [0] viene assegnato il valore finale di ‘a’. Ho provato a usare i vettori ma VS Express 2013 non mi è piaciuto molto. Ricorda inoltre che ‘a’ inizia da uno per evitare la sovrascrittura [0] ed è inizializzato all’inizio per evitare errori. Non sono esperto, pensavo di condividerlo.

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

Uno dei motivi più comuni per cui dovresti cercare questo è che vuoi passare un array a una funzione e non dover passare un altro argomento per la sua dimensione. Inoltre, ti piacerebbe che la dimensione dell’array fosse dynamic. Quella matrice potrebbe contenere oggetti, non primitive, e gli oggetti possono essere complessi, tanto che size_of () è un’opzione non sicura per il calcolo del conteggio.

Come altri hanno suggerito, prendere in considerazione l’uso di un file std :: vector o list, invece di una matrice primitiva. Sui vecchi compilatori, tuttavia, non avresti ancora la soluzione finale che vorresti facendo semplicemente, però, perché compilare il contenitore richiede una serie di brutte linee push_back (). Se sei come me, vuoi una soluzione a linea singola con oggetti anonimi coinvolti.

Se vai con il contenitore STL alternativo a un array primitivo, questo post SO può esserti utile per modi di inizializzarlo: qual è il modo più semplice per inizializzare un vettore std :: con elementi hardcoded?

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

Crea una struct o una class come contenitore per la tua collezione di oggetti. Definire una funzione di sovraccarico dell’operatore per <<.

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

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

 someFunc( MyObjectList &objects ); 

Quindi, puoi chiamare quella funzione, in questo modo:

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

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

Evitare di utilizzare il tipo insieme a sizeof, come sizeof(array)/sizeof(char) , viene improvvisamente corrotto se si modifica il tipo di array.

In Visual Studio, si ha l’equivalente se sizeof(array)/sizeof(*array) . Puoi semplicemente digitare _countof(array)

Per il vecchio compilatore g ++, puoi farlo

 template  char (&helper(T (&)[N]))[N]; #define arraysize(array) (sizeof(helper(array))) int main() { int a[10]; std::cout << arraysize(a) << std::endl; return 0; } 

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

 unsigned int x[] -> int x[] 

di quanto si potrebbe rendere l’elemento dell’array 1 più grande di quello che è necessario per farlo. Per l’ultimo elemento inseriresti un tipo che è incluso nello specificatore di tipo espanso ma che normalmente non utilizzeresti ad esempio usando l’esempio precedente, l’ultimo elemento sarebbe -1. Questo ti permette (usando un ciclo for) di trovare l’ultimo elemento di un array.

Fornisco una soluzione complicata qui:

Puoi sempre archiviare la length nel primo elemento:

 // malloc/new arr[0] = length; arr++; // do anything. int len = *(arr-1); free(--arr); 

Il costo è che devi --arr quando invochi free

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 digita il seguente codice:

 sizeof(global) / 4; 

La sizeof (NAME_OF_ARRAY) / 4 restituirà il numero di elementi per il nome dell’array dato.