So finden Sie die Array-Größe in C++

Um die Länge eines Arrays in C++ zu bestimmen, zählt man seine Elemente. Welche Technik passt, hängt vom Typ ab: sizeof eignet sich für ein eingebautes Array in dem Gültigkeitsbereich, in dem es deklariert wurde, size() für std::array oder std::vector und std::size als allgemeiner Aufruf der Standardbibliothek. Eine bereichsbasierte for-Schleife kann die Elemente eines Bereichs zählen, den man bereits durchlaufen kann.

Elemente in C++ mit einer bereichsbasierten for-Schleife zählen

Eine bereichsbasierte for-Schleife durchläuft jedes Element eines Arrays oder eines anderen iterierbaren Bereichs. Erhöhen Sie bei jedem Durchlauf einen Zähler, um die Elemente zu zählen:

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

Damit wird der Bereich gezählt, den values bereitstellt. Die Schleife ermittelt nicht die Größe des Speicherbereichs, auf den ein roher Zeiger verweist, oder die Größe dynamisch reservierten Speichers. Bewahren Sie in solchen Fällen die Elementanzahl separat auf oder verwenden Sie einen Container, der seine Größe angibt.

Die Länge eines eingebauten Arrays mit sizeof ermitteln

Solange ein eingebautes Array im aktuellen Gültigkeitsbereich noch ein Array ist, teilen Sie seine gesamte Größe in Bytes durch die Größe eines Elements in Bytes:

#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) gibt die Anzahl der Bytes an, die das gesamte Array belegt; sizeof(values[0]) liefert die Anzahl der Bytes eines einzelnen Elements. Der Quotient ist die Elementanzahl. Das Beispiel bindet <cstddef> für std::size_t ein.

Als Berechnung der Elementanzahl funktioniert dies nicht mehr, sobald ein Array an eine Funktion übergeben wird. Ein Parameter in der Schreibweise int values[] wird zu int* values angepasst. Innerhalb der Funktion misst sizeof(values) dann die Größe des Zeigers und nicht die des ursprünglichen Arrays. Der resultierende Quotient hängt von der jeweiligen Implementierung und den Größen von Zeiger und Element ab und liefert daher keine portable Elementanzahl. Übergeben Sie die Anzahl separat oder nehmen Sie stattdessen einen Container entgegen.

size() mit std::array und std::vector verwenden

Sowohl std::array als auch std::vector stellen eine size()-Memberfunktion bereit, die die Anzahl der Elemente zurückgibt. std::array bildet ein Array fester Größe ab, während sich die Größe eines Vektors beim Hinzufügen oder Entfernen von Elementen ändern kann.

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

Verwenden Sie die Memberfunktion des jeweiligen Containers. std::array::size() gibt dessen feste Elementanzahl zurück; std::vector::size() liefert die aktuelle Anzahl der Elemente im Vektor.

Die Array-Länge mit std::end() und std::begin() ermitteln

Bei einem eingebauten Array verweist std::begin auf das erste Element und std::end auf die Position direkt hinter dem letzten Element. Die Differenz der beiden Zeiger ergibt die Anzahl der Elemente dazwischen. Binden Sie für diese Funktionen <iterator> ein.

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

Die Subtraktion ist gültig, weil beide Zeiger auf dasselbe Array oder auf dessen Position direkt hinter dem letzten Element verweisen. Das ist bei eingebauten Arrays nützlich. Bei std::array oder std::vector ist die Memberfunktion size() in der Regel verständlicher.

Die Anzahl der Elemente mit std::size() ermitteln

std::size ist eine Funktion der Standardbibliothek, die eine Elementanzahl zurückgibt. Sie funktioniert mit eingebauten Arrays und Standardcontainern wie std::array und std::vector. Binden Sie für ihre Verwendung <iterator> ein.

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

Im Gegensatz zur Memberfunktion size() wird std::size(container) als freie Funktion aufgerufen. Sie bietet eine einheitliche Schreibweise für die unterstützten Array- und Containertypen; die jeweilige size()-Memberfunktion bleibt weiterhin verfügbar.

Die passende Methode für Ihren Array-Typ auswählen

• Für ein eingebautes Array im selben Gültigkeitsbereich wie seine Deklaration können Sie sizeof(array) / sizeof(array[0]) oder std::size(array) verwenden.
• Für std::array und std::vector empfiehlt sich deren Memberfunktion size(). Wenn ein einheitlicher Funktionsaufruf hilfreich ist, verwenden Sie std::size(container).
• Verwenden Sie std::end(array) - std::begin(array), wenn die Subtraktion von Iteratoren zum umgebenden Code passt.
• Eine bereichsbasierte for-Schleife eignet sich, wenn Sie einen iterierbaren Bereich durch Durchlaufen seiner Elemente zählen möchten.
• Bei einem Zeiger oder einem dynamisch reservierten Array müssen Sie die Anzahl separat aufbewahren oder einen Container verwenden. Der Zeiger allein enthält keine Elementanzahl des reservierten Speicherbereichs.

Entscheidend ist der Unterschied zwischen der Speichergröße in Bytes und der Anzahl der Elemente. sizeof misst Bytes. Teilen Sie durch die Byte-Größe eines Elements nur dann, wenn sich der Ausdruck noch auf das vollständige eingebaute Array bezieht. Containerfunktionen zur Größenabfrage und die Subtraktion von Iteratoren liefern direkt Elementanzahlen.