std:: array

std::array ist ein Container, der Arrays fester Größe kapselt.

Dieser Container ist ein Aggregattyp mit derselben Semantik wie ein struct, das ein C-style-Array T [ N ] als sein einziges nicht-statisches Datenelement hält. Im Gegensatz zu einem C-style-Array zerfällt es nicht automatisch zu T * . Als Aggregattyp kann es mit Aggregatinitialisierung initialisiert werden, wobei maximal N Initialisierer angegeben werden können, die in T konvertierbar sind: std :: array < int , 3 > a = { 1 , 2 , 3 } ; .

Die Struktur kombiniert die Leistung und Zugänglichkeit eines C-Stil-Arrays mit den Vorteilen eines Standard-Containers, wie das Wissen über die eigene Größe, Unterstützung von Zuweisung, Random-Access-Iteratoren, etc.

std::array erfüllt die Anforderungen von Container und ReversibleContainer mit der Ausnahme, dass ein standardmäßig konstruiertes Array nicht leer ist und dass die Komplexität des Austauschs linear ist, erfüllt die Anforderungen von ContiguousContainer , (seit C++17) und erfüllt teilweise die Anforderungen von SequenceContainer .

Es gibt einen Sonderfall für ein Array mit der Länge Null ( N == 0 ). In diesem Fall gilt array. begin ( ) == array. end ( ) , was einen eindeutigen Wert darstellt. Der Effekt des Aufrufs von front ( ) oder back ( ) auf ein Array der Größe Null ist undefiniert.

Ein Array kann auch als Tupel von N Elementen desselben Typs verwendet werden.

Iterator-Invalidierung

In der Regel werden Iteratoren auf ein Array während der gesamten Lebensdauer des Arrays niemals ungültig. Man sollte jedoch beachten, dass während eines swap der Iterator weiterhin auf dasselbe Array-Element zeigt und somit seinen Wert ändert.

Template-Parameter

Mitgliedertypen

Memberfunktionen

Nicht-Member-Funktionen

Hilfsklassen

Beispiel

#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <string>
int main()
{
    // Konstruktion verwendet Aggregatinitialisierung
    std::array<int, 3> a1{{1, 2, 3}}; // Doppelte Klammern erforderlich in C++11 vor
                                      // der CWG 1270 Revision (nicht benötigt in C++11
                                      // nach der Revision und in C++14 und höher)
    std::array<int, 3> a2 = {1, 2, 3}; // Doppelte Klammern nach = nie erforderlich
    // Container-Operationen werden unterstützt
    std::sort(a1.begin(), a1.end());
    std::ranges::reverse_copy(a2, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    // Bereichsbasierte for-Schleife wird unterstützt
    std::array<std::string, 2> a3{"E", "\u018E"};
    for (const auto& s : a3)
        std::cout << s << ' ';
    std::cout << '\n';
    // Deduktionsleitfaden für Array-Erstellung (seit C++17)
    [[maybe_unused]] std::array a4{3.0, 1.0, 4.0}; // std::array<double, 3>
    // Verhalten nicht spezifizierter Elemente ist gleich wie bei eingebauten Arrays
    [[maybe_unused]] std::array<int, 2> a5; // Keine Listeninitialisierung, a5[0] und a5[1]
                                            // werden standardinitialisiert
    [[maybe_unused]] std::array<int, 2> a6{}; // Listeninitialisierung, beide Elemente werden wert-
                                              // initialisiert, a6[0] = a6[1] = 0
    [[maybe_unused]] std::array<int, 2> a7{1}; // Listeninitialisierung, nicht spezifiziertes Element wird wert-
                                               // initialisiert, a7[0] = 1, a7[1] = 0
}

3 2 1
E Ǝ

Siehe auch