std::array

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::array

Membertypen
Memberfunktionen
Elementzugriff array::at array::operator[]    array::front array::back array::data Operationen array::fill array::swap	Iteratoren array::beginarray::cbegin array::endarray::cend array::rbeginarray::crbegin    array::rendarray::crend	Kapazität array::empty array::size array::max_size
Nicht-Member-Funktionen
operator==operator<=> (C++20) get(std::array) swap(std::array) to_array (C++20)	operator|=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Hilfsklassen
tuple_size<std::array>
tuple_element<std::array>
Deduction guides (C++17)

 

Definiert in der Header-Datei <array>
template<     class T,     std::size_t N > struct array;		(seit C++11)

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

Dieser Container ist ein Aggregattyp mit denselben Semantiken wie eine Struktur, die ein C-Style-Array T[N] als einziges nicht-statisches Datenelement enthält. Im Gegensatz zu einem C-Style-Array verfällt es nicht automatisch zu T*. Als Aggregattyp kann es mit Aggregatinitialisierung initialisiert werden, wobei höchstens N Initialisierer angegeben werden, die zu T konvertierbar sind: std::array<int, 3> a = {1, 2, 3};.

Die Struktur kombiniert die Leistung und Zugänglichkeit eines C-Style-Arrays mit den Vorteilen eines Standardcontainers, wie z. B. der Kenntnis seiner eigenen Größe, der Unterstützung von Zuweisungen, von zufälligen Zugriffsiteratoren usw.

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

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

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

Iterator-Invalidierung

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

Template-Parameter

T	-	Elementtyp Muss MoveConstructible und MoveAssignable sein.
N	-	die Anzahl der Elemente im Array oder ​0​.

Member-Typen

Mitgliedertyp	Definition
value_type	T
size_type	std::size_t
difference_type	std::ptrdiff_t
Referenz	value_type&
const_reference	const value_type&
Zeiger	value_type*
const_pointer	const value_type*
iterator	LegacyRandomAccessIterator und LegacyContiguousIterator zu value_type (bis C++17) LegacyRandomAccessIterator und LegacyContiguousIterator, der ein LiteralType für value_type ist (seit C++17) (bis C++20) LegacyRandomAccessIterator, contiguous_iterator, und ConstexprIterator zu value_type (seit C++20)
const_iterator	LegacyRandomAccessIterator und LegacyContiguousIterator zu const value_type (bis C++17) LegacyRandomAccessIterator und LegacyContiguousIterator, der ein LiteralType für const value_type ist (seit C++17) (bis C++20) LegacyRandomAccessIterator, contiguous_iterator, und ConstexprIterator zu const value_type (seit C++20)
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>

Member-Funktionen

Implizit definierte Member-Funktionen
(Konstruktor) (implizit deklariert)	initialisiert das Array gemäß den Regeln der Aggregatinitialisierung (beachten Sie, dass die Standardinitialisierung für Nicht-Klassen-T zu undefinierten Werten führen kann) (öffentliche Memberfunktion)
(Destruktor) (implizit deklariert)	zerstört jedes Element des Arrays (öffentliche Memberfunktion)
operator= (implizit deklariert)	überschreibt jedes Element des Arrays mit dem entsprechenden Element eines anderen Arrays (öffentliche Memberfunktion)
Elementzugriff
at	Greift mit Überprüfung auf ein bestimmtes Element zu (public member function)
operator[]	Greift auf ein bestimmtes Element zu (public member function)
front	Greift auf das erste Element zu (public member function)
back	Greift auf das letzte Element zu (public member function)
data	Direkter Zugriff auf den zugrundeliegenden zusammenhängenden Speicher (public member function)
Iteratoren
begincbegin	gibt einen Iterator zum Anfang zurück (public member function)
endcend	gibt einen Iterator zum Ende zurück (public member function)
rbegincrbegin	gibt einen Reverse-Iterator zum Anfang zurück (public member function)
rendcrend	gibt einen Reverse-Iterator zum Ende zurück (public member function)
Kapazität
empty	prüft, ob der Container leer ist (public member function)
size	Gibt die Anzahl der Elemente zurück (public member function)
max_size	Gibt die maximal mögliche Anzahl von Elementen zurück (public member function)
Operationen
fill	füllt den Container mit einem angegebenen Wert (öffentliche Member-Funktion)
swap	tauscht die Inhalte (public member function)

Nicht-Member-Funktionen

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++11)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++11)(entfernt in C++20)(C++20)	vergleicht die Werte zweier arrays lexikographisch (function template)
get(std::array) (C++11)	greift auf ein Element eines arrays zu (Funktionstemplate)
std::swap(std::array) (C++11)	spezialisiert den Algorithmus std::swap (function template)
to_array (C++20)	erstellt ein std::array-Objekt aus einem eingebauten Array (Funktionsschablone)

Hilfsklassen

std::tuple_size<std::array> (C++11)	ermittelt die Größe eines arrays (Klassentemplatenspezialisierung)
std::tuple_element<std::array> (C++11)	ermittelt den Typ der Elemente von array (Klassentemplatenspezialisierung)

Deduction Guides

(seit C++17)

Beispiel

Führen Sie diesen Code aus

#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <string>
 
int main()
{
    // Construction uses aggregate initialization
    std::array<int, 3> a1{{1, 2, 3}}; // Double-braces required in C++11 prior to
                                      // the CWG 1270 revision (not needed in C++11
                                      // after the revision and in C++14 and beyond)
 
    std::array<int, 3> a2 = {1, 2, 3}; // Double braces never required after =
 
    // Container operations are supported
    std::sort(a1.begin(), a1.end());
    std::ranges::reverse_copy(a2, std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
 
    // Ranged for loop is supported
    std::array<std::string, 2> a3{"E", "\u018E"};
    for (const auto& s : a3)
        std::cout << s << ' ';
    std::cout << '\n';
 
    // Deduction guide for array creation (since C++17)
    [[maybe_unused]] std::array a4{3.0, 1.0, 4.0}; // std::array<double, 3>
 
    // Behavior of unspecified elements is the same as with built-in arrays
    [[maybe_unused]] std::array<int, 2> a5; // No list init, a5[0] and a5[1]
                                            // are default initialized
    [[maybe_unused]] std::array<int, 2> a6{}; // List init, both elements are value
                                              // initialized, a6[0] = a6[1] = 0
    [[maybe_unused]] std::array<int, 2> a7{1}; // List init, unspecified element is value
                                               // initialized, a7[0] = 1, a7[1] = 0
}

Ausgabe

3 2 1
E Ǝ

Siehe auch

inplace_vector (C++26)	reservierbares, festes Kapazitäts-Array, Inplace, zusammenhängend (Klassenvorlage)
vector	reservierbares, zusammenhängendes Array (Klassenvorlage)
deque	Doppelt-endende Warteschlange (Klassenvorlage)
make_array (Library Fundamentals TS v2)	erstellt ein std::array-Objekt, dessen Größe und optionaler Elementtyp aus den Argumenten abgeleitet werden (Funktionstemplate)