Wie finde ich die Länge eines Arrays?

Gibt es eine Möglichkeit herauszufinden, wie viele Werte ein Array hat? Es würde auch funktionieren, zu erkennen, ob ich das Ende eines Arrays erreicht habe oder nicht.

Wenn Sie ein Array im C-Stil meinen, können Sie Folgendes tun:

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

Das funktioniert nicht auf Zeiger (dh es wird nicht Arbeit für eine der folgenden):

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

oder:

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

int a[7];
func(a);

Wenn Sie in C ++ ein solches Verhalten wünschen, sollten Sie eine Containerklasse verwenden. wahrscheinlich std::vector.

Wie andere gesagt haben, können Sie das verwenden, sizeof(arr)/sizeof(*arr)aber dies gibt Ihnen die falsche Antwort für Zeigertypen, die keine Arrays sind.

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

Dies hat die nette Eigenschaft, dass es nicht möglich ist, für Nicht-Array-Typen zu kompilieren (Visual Studio hat _countofdies). Das constexprmacht dies zu einem Ausdruck für die Kompilierungszeit, sodass es keine Nachteile gegenüber dem Makro hat (zumindest keine, die ich kenne).

Sie können auch std::arrayC ++ 11 verwenden, das seine Länge ohne Overhead über ein natives C-Array verfügbar macht.

C ++ 17 hat std::size()im <iterator>Header das Gleiche und funktioniert auch für STL-Container (dank @Jon C ).

Dadurch sizeof( myArray )erhalten Sie die Gesamtzahl der für dieses Array zugewiesenen Bytes. Sie können dann die Anzahl der Elemente im Array ermitteln, indem Sie durch die Größe eines Elements im Array dividieren:sizeof( myArray[0] )

Obwohl dies eine alte Frage ist, lohnt es sich, die Antwort auf C ++ 17 zu aktualisieren. In der Standardbibliothek gibt es jetzt die Vorlagenfunktion std::size(), die die Anzahl der Elemente in einem Standardcontainer oder einem Array im C-Stil zurückgibt. Zum Beispiel:

#include <iterator>

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

Gibt es eine Möglichkeit herauszufinden, wie viele Werte ein Array hat?

Ja!

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

Es würde auch funktionieren, zu erkennen, ob ich das Ende eines Arrays erreicht habe oder nicht.

Ich sehe keinen Weg dafür, es sei denn, Ihr Array ist ein Array von Zeichen (dh Zeichenfolge).

PS: In C ++ immer verwenden std::vector. Es gibt mehrere eingebaute Funktionen und eine erweiterte Funktionalität.

std::vectorhat eine Methode, size()die die Anzahl der Elemente im Vektor zurückgibt.

(Ja, das ist eine ironische Antwort)

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

Seit C ++ 11 werden einige neue Vorlagen eingeführt, um die Schmerzen beim Umgang mit der Array-Länge zu verringern. Alle von ihnen sind in der Kopfzeile definiert <type_traits>.

• std::rank<T>::value

  Wenn Tes sich um einen Array-Typ handelt, wird der Elementkonstantenwert angegeben, der der Anzahl der Dimensionen des Arrays entspricht. Für jeden anderen Typ ist der Wert 0.

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

  Wenn Tes sich um einen Array-Typ handelt, wird der Elementkonstantenwert angegeben, der der Anzahl der Elemente entlang der Ndritten Dimension des Arrays entspricht, wenn Nin [0, std::rank<T>::value). Für jeden anderen Typ oder wenn Tdas Array unbekannt in seiner ersten Dimension gebunden Nist und 0 ist, ist der Wert 0.

• std::remove_extent<T>::type

  Wenn Tes sich um ein Array eines Typs handelt X, wird der Typ typeedef des Mitglieds gleich angegeben X, andernfalls ist type T. Beachten Sie, dass bei Teinem mehrdimensionalen Array nur die erste Dimension entfernt wird.

• std::remove_all_extents<T>::type

  Wenn Tes sich um ein mehrdimensionales Array eines Typs handelt X, wird der Typ typeedef des Elements gleich angegeben X, andernfalls ist type T.

Um die Länge für eine beliebige Dimension eines multidimentiellen Arrays zu ermitteln, decltypekann eine Kombination mit verwendet werden std::extent. Zum Beispiel:

#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, um die Gesamtzahl der Elemente in einem multidimentionalen Array zu erhalten:

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

Oder fügen Sie es in eine Funktionsvorlage ein:

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

Weitere Beispiele für deren Verwendung finden Sie unter den folgenden Links.

Es gibt auch den Weg TR1 / C ++ 11 / C ++ 17 (siehe 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

Anstatt die eingebaute Array-Funktion aka zu verwenden:

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

Sie sollten die Array-Klasse und die Array-Vorlage verwenden. Versuchen:

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

Wenn Sie nun die Länge des Arrays ermitteln möchten, müssen Sie lediglich die Größenfunktion in der Array-Klasse verwenden.

Name_of_Array.size();

und das sollte die Länge der Elemente im Array zurückgeben.

In C ++ kann man mithilfe der std :: array-Klasse zum Deklarieren eines Arrays leicht die Größe eines Arrays und auch das letzte Element ermitteln.

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

Tatsächlich verfügt die Array-Klasse über viele andere Funktionen, mit denen wir Array als Standardcontainer verwenden können.
Referenz 1 zu C ++ std :: array class
Referenz 2 zu std :: array class
Die Beispiele in den Referenzen sind hilfreich.

Dies ist eine ziemlich alte und legendäre Frage, und es gibt bereits viele erstaunliche Antworten. Mit der Zeit werden den Sprachen jedoch neue Funktionen hinzugefügt, sodass wir die Dinge entsprechend den neuen verfügbaren Funktionen ständig aktualisieren müssen.

Mir ist gerade aufgefallen, dass noch niemand etwas über C ++ 20 erwähnt hat. Also dachte ich, ich schreibe eine Antwort.

C ++ 20

In C ++ 20 gibt es eine neue bessere Möglichkeit, der Standardbibliothek die Länge des Arrays zu ermitteln, d std:ssize(). H. Diese Funktion gibt a zurück signed value.

#include <iostream>

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

C ++ 17

In C ++ 17 gab es (zu dieser Zeit) einen besseren Weg für denselben, der in std::size()definiert ist 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 Diese Methode funktioniert auch für vector.

Alt

Dieser traditionelle Ansatz wird bereits in vielen anderen Antworten erwähnt.

#include <iostream>

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

Nur zu Ihrer Information, wenn Sie sich fragen, warum dieser Ansatz nicht funktioniert, wenn das Array an eine andere Funktion übergeben wird . Der Grund ist,

Ein Array wird in C ++ nicht als Wert übergeben, sondern der Zeiger auf das Array wird übergeben. Wie in einigen Fällen kann das Übergeben der gesamten Arrays ein teurer Betrieb sein. Sie können dies testen, indem Sie das Array an eine Funktion übergeben und dort einige Änderungen am Array vornehmen und das Array dann erneut in main drucken. Sie erhalten aktualisierte Ergebnisse.

Und wie Sie bereits wissen, sizeof()gibt die Funktion die Anzahl der Bytes an, sodass in einer anderen Funktion die Anzahl der dem Zeiger zugewiesenen Bytes und nicht das gesamte Array zurückgegeben wird. Dieser Ansatz funktioniert also nicht.

Aber ich bin sicher, Sie können einen guten Weg finden, dies gemäß Ihren Anforderungen zu tun.

Viel Spaß beim Codieren.

Sie haben eine Reihe von Optionen, um eine C-Array-Größe zu erhalten.

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;

Hier ist eine Implementierung ArraySizevon 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) überprüft die Größe von (arr) (Anzahl der Bytes im Array) und sizeof (* (arr)) (Anzahl der Bytes in einem Array-Element). Wenn das erstere durch das letztere teilbar ist, ist arr möglicherweise tatsächlich ein Array. In diesem Fall ist das Teilungsergebnis die Anzahl der Elemente im Array. Andernfalls kann arr möglicherweise kein Array sein, und wir generieren einen Compilerfehler, um zu verhindern, dass der Code kompiliert wird.

Da die Größe von bool implementierungsdefiniert ist, müssen wir! (Sizeof (a) & sizeof (* (a))) in size_t umwandeln, um sicherzustellen, dass das Endergebnis den Typ size_t hat.

Dieses Makro ist nicht perfekt, da es bestimmte Zeiger fälschlicherweise akzeptiert, nämlich wenn die Zeigergröße durch die Spitzengröße teilbar ist. Da unser gesamter Code einen 32-Bit-Compiler durchlaufen muss, bei dem ein Zeiger 4 Byte groß ist, werden alle Zeiger auf einen Typ mit einer Größe von 3 oder mehr als 4 (zu Recht) abgelehnt.

Für C ++ / CX (beim Schreiben von UWP-Apps mit C ++ in Visual Studio) können wir die Anzahl der Werte in einem Array mithilfe der size()Funktion ermitteln.

Quellcode:

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

Wenn Sie coutdie size_of_arrayAusgabe wird sein:

>>> 4

sizeof(array_name)gibt die Größe des gesamten Arrays und sizeof(int)die Größe des Datentyps jedes Array-Elements an.

Wenn Sie also die Größe des gesamten Arrays durch die Größe eines einzelnen Elements des Arrays dividieren, erhalten Sie die Länge des Arrays.

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

ANTWORT :

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

ERKLÄRUNG :

Da der Compiler für jeden Datentyp einen bestimmten Speicherbereich beiseite legt und ein Array einfach eine Gruppe davon ist, teilen Sie einfach die Größe des Arrays durch die Größe des Datentyps. Wenn ich ein Array mit 30 Zeichenfolgen habe, reserviert mein System 24 Bytes für jedes Element (Zeichenfolge) des Arrays. Bei 30 Elementen sind das insgesamt 720 Bytes. 720/24 == 30 Elemente. Der kleine, enge Algorithmus dafür ist:

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

number_of_elements = 720/24

Beachten Sie, dass Sie nicht wissen müssen, um welchen Datentyp es sich bei dem Array handelt, auch wenn es sich um einen benutzerdefinierten Datentyp handelt.

Nur ein Gedanke, aber gerade beschlossen, eine Zählervariable zu erstellen und die Arraygröße in Position [0] zu speichern. Ich habe den größten Teil des Codes gelöscht, den ich in der Funktion hatte, aber nach dem Verlassen der Schleife wird prime [0] der Endwert 'a' zugewiesen. Ich habe versucht, Vektoren zu verwenden, aber VS Express 2013 hat das nicht sehr gut gefallen. Beachten Sie auch, dass 'a' bei eins beginnt, um ein Überschreiben [0] zu vermeiden, und am Anfang initialisiert wird, um Fehler zu vermeiden. Ich bin kein Experte, dachte nur, ich würde teilen.

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

Eine gute Lösung, die Generika verwendet:

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

Rufen Sie dann einfach arraysize(_Array);auf, um die Länge des Arrays zu ermitteln.

Quelle

Für den alten g ++ - Compiler können Sie dies tun

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

Ich biete hier eine knifflige Lösung:

Sie können immer lengthim ersten Element speichern :

// malloc/new

arr[0] = length;
arr++;

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

free(--arr); 

Die Kosten müssen Sie --arrbeim Aufrufen tragenfree

Sie können die Länge eines Arrays wie folgt ermitteln:

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

Sie können einfach diesen Ausschnitt verwenden:

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

}

und hier ist die Referenz: http://www.cplusplus.com/reference/array/array/size/

Vermeiden Sie es, den Typ zusammen mit sizeof, as zu verwenden sizeof(array)/sizeof(char) plötzlich , wenn Sie den Typ des Arrays ändern.

Im Visual Studio haben Sie das Äquivalenz if sizeof(array)/sizeof(*array). Sie können einfach eingeben_countof(array)

Ich persönlich würde vorschlagen (wenn Sie aus irgendeinem Grund nicht mit speziellen Funktionen arbeiten können), zuerst die Kompatibilität des Arrays-Typs über das hinaus zu erweitern, als was Sie normalerweise verwenden würden (wenn Sie Werte ≥ 0 speichern würden:

unsigned int x[] -> int x[]

als Sie das Array 1-Element größer machen würden, als Sie es machen müssen. Für das letzte Element würden Sie einen Typ einfügen, der im erweiterten Typbezeichner enthalten ist, den Sie jedoch normalerweise nicht verwenden würden, z. B. im vorherigen Beispiel wäre das letzte Element -1. Auf diese Weise können Sie (mithilfe einer for-Schleife) das letzte Element eines Arrays finden.

Einer der häufigsten Gründe, warum Sie danach suchen würden, ist, dass Sie ein Array an eine Funktion übergeben möchten und kein anderes Argument für seine Größe übergeben müssen. Im Allgemeinen möchten Sie auch, dass die Arraygröße dynamisch ist. Dieses Array enthält möglicherweise Objekte, keine Grundelemente, und die Objekte sind möglicherweise so komplex, dass size_of () eine nicht sichere Option für die Berechnung der Anzahl ist.

Wie andere vorgeschlagen haben, sollten Sie anstelle eines primitiven Arrays einen std :: -Vektor oder eine Liste usw. verwenden. Auf alten Compilern hätten Sie jedoch immer noch nicht die endgültige Lösung, die Sie wahrscheinlich wollen, wenn Sie dies einfach tun, da das Auffüllen des Containers eine Reihe hässlicher push_back () -Zeilen erfordert. Wenn Sie wie ich sind, möchten Sie eine einzeilige Lösung mit anonymen Objekten.

Wenn Sie sich für eine STL-Container-Alternative zu einem primitiven Array entscheiden, kann dieser SO-Beitrag für Sie hilfreich sein, um ihn zu initialisieren: Was ist der einfachste Weg, einen std :: -Vektor mit fest codierten Elementen zu initialisieren?

Hier ist eine Methode, die ich dafür verwende und die universell über Compiler und Plattformen hinweg funktioniert:

Erstellen Sie eine Struktur oder Klasse als Container für Ihre Objektsammlung. Definieren Sie eine Operatorüberladungsfunktion für <<.

class MyObject;

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

Sie können Funktionen erstellen, die Ihre Struktur als Parameter verwenden, z.

someFunc( MyObjectList &objects );

Dann können Sie diese Funktion folgendermaßen aufrufen:

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

Auf diese Weise können Sie eine Sammlung von Objekten mit dynamischer Größe erstellen und an eine Funktion in einer einzigen klaren Linie übergeben!

Nehmen wir an, Sie haben ein globales Array oben auf der Seite deklariert

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

Geben Sie den folgenden Code ein, um herauszufinden, wie viele Elemente (in c ++) im Array vorhanden sind:

sizeof(global) / 4;

Die Größe von (NAME_OF_ARRAY) / 4 gibt Ihnen die Anzahl der Elemente für den angegebenen Array-Namen zurück.