Namespaces
Variants

std:: deque

From cppreference.net
Definiert im Header <deque>
template <

class T,
class Allocator = std:: allocator < T >

> class deque ;
(1)
namespace pmr {

template < class T >
using deque = std :: deque < T, std:: pmr :: polymorphic_allocator < T >> ;

}
(2) (seit C++17)

std::deque (Double-Ended-Queue) ist eine indizierte Sequenz-Container-Klasse, die schnelles Einfügen und Löschen an ihrem Anfang und Ende ermöglicht. Darüber hinaus machen Einfüge- und Löschoperationen an beiden Enden einer Deque Zeiger oder Referenzen auf die restlichen Elemente niemals ungültig.

Im Gegensatz zu std::vector sind die Elemente einer deque nicht zusammenhängend gespeichert: Typische Implementierungen verwenden eine Sequenz von einzeln allokierten Arrays fester Größe mit zusätzlicher Buchhaltung, was bedeutet, dass der indizierte Zugriff auf deque zwei Pointer-Dereferenzierungen durchführen muss, verglichen mit dem indizierten Zugriff von vector, der nur eine durchführt.

Die Speicherung eines Deque wird automatisch nach Bedarf erweitert und verkleinert. Die Erweiterung eines Deque ist kostengünstiger als die Erweiterung eines std::vector , da sie keine Kopie der vorhandenen Elemente an einen neuen Speicherort beinhaltet. Andererseits haben Deques typischerweise hohe minimale Speicherkosten; ein Deque, das nur ein Element enthält, muss sein vollständiges internes Array allokieren (z.B. 8-fache Objektgröße auf 64-Bit libstdc++; 16-fache Objektgröße oder 4096 Bytes, je nachdem was größer ist, auf 64-Bit libc++).

Die Komplexität (Effizienz) gängiger Operationen auf Deques ist wie folgt:

  • Direktzugriff - konstant O(1) .
  • Einfügen oder Entfernen von Elementen am Ende oder Anfang - konstant O(1) .
  • Einfügen oder Entfernen von Elementen - linear O(n) .

std::deque erfüllt die Anforderungen von Container , AllocatorAwareContainer , SequenceContainer und ReversibleContainer .

Alle Memberfunktionen von std::deque sind constexpr : Es ist möglich, std::deque -Objekte in der Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden.

Allerdings können std::deque -Objekte im Allgemeinen nicht constexpr sein, da jeder dynamisch allokierte Speicher in derselben Auswertung des konstanten Ausdrucks freigegeben werden muss.

(since C++26)

Inhaltsverzeichnis

Template-Parameter

T - Der Typ der Elemente.
T muss die Anforderungen von CopyAssignable und CopyConstructible erfüllen. (bis C++11)
Die Anforderungen an die Elemente hängen von den tatsächlich durchgeführten Operationen auf dem Container ab. Allgemein wird gefordert, dass der Elementtyp ein vollständiger Typ ist und die Anforderungen von Erasable erfüllt, jedoch stellen viele Member-Funktionen strengere Anforderungen. (seit C++11)

Allocator - Ein Allokator, der zur Beschaffung/Freigabe von Speicher und zur Konstruktion/Destruktion der Elemente in diesem Speicher verwendet wird. Der Typ muss die Anforderungen von Allocator erfüllen. Das Verhalten ist undefiniert (bis C++20) Das Programm ist fehlerhaft (seit C++20) wenn Allocator::value_type nicht identisch mit T ist.

Iterator-Invalidierung

Operationen Ungültig
Alle schreibgeschützten Operationen. Niemals.
swap , std::swap Der Past-the-End-Iterator kann ungültig werden (implementierungsdefiniert).
shrink_to_fit , clear , insert ,
emplace , push_front , push_back ,
emplace_front , emplace_back
Immer.
erase Wenn am Anfang gelöscht wird - nur die gelöschten Elemente.

Wenn am Ende gelöscht wird - nur die gelöschten Elemente und der Past-the-End-Iterator.
Andernfalls - alle Iteratoren werden ungültig.

Es ist nicht spezifiziert, wann der Past-the-End-Iterator ungültig wird.

(bis C++11)

Der Past-the-End-Iterator wird ebenfalls ungültig, es sei denn, die gelöschten
Elemente befinden sich am Anfang des Containers und das letzte
Element wird nicht gelöscht.

(seit C++11)
resize Wenn die neue Größe kleiner als die alte ist - nur die gelöschten Elemente und der
Past-the-End-Iterator.

Wenn die neue Größe größer als die alte ist - alle Iteratoren werden ungültig.
Andernfalls - keine Iteratoren werden ungültig.

pop_front , pop_back Für das gelöschte Element.

Der Past-the-End-Iterator kann ungültig werden (implementierungsdefiniert).

(bis C++11)

Der Past-the-End-Iterator wird ebenfalls ungültig.

(seit C++11)

Ungültigkeitshinweise

  • Beim Einfügen an einem der beiden Enden der Deque werden Referenzen durch insert und emplace nicht ungültig.
  • push_front , push_back , emplace_front und emplace_back machen keine Referenzen auf Elemente der Deque ungültig.
  • Beim Löschen an einem der beiden Enden der Deque werden Referenzen auf nicht gelöschte Elemente durch erase , pop_front und pop_back nicht ungültig.
  • Ein Aufruf von resize mit einer kleineren Größe macht keine Referenzen auf nicht gelöschte Elemente ungültig.
  • Ein Aufruf von resize mit einer größeren Größe macht keine Referenzen auf Elemente der Deque ungültig.

Mitgliedertypen

Mitgliedstyp Definition
value_type T
allocator_type Allocator
size_type Vorzeichenloser Ganzzahltyp (üblicherweise std::size_t )
difference_type Vorzeichenbehafteter Ganzzahltyp (üblicherweise std::ptrdiff_t )
reference value_type &
const_reference const value_type &
pointer

Allocator::pointer

(bis C++11)

std:: allocator_traits < Allocator > :: pointer

(seit C++11)
const_pointer

Allocator::const_pointer

(bis C++11)

std:: allocator_traits < Allocator > :: const_pointer

(seit C++11)
iterator LegacyRandomAccessIterator und ConstexprIterator (seit C++26) zu value_type
const_iterator LegacyRandomAccessIterator und ConstexprIterator (seit C++26) zu const value_type
reverse_iterator std:: reverse_iterator < iterator >
const_reverse_iterator std:: reverse_iterator < const_iterator >

Memberfunktionen

konstruiert den deque
(öffentliche Elementfunktion)
zerstört die deque
(öffentliche Elementfunktion)
weist dem Container Werte zu
(öffentliche Elementfunktion)
weist dem Container Werte zu
(öffentliche Elementfunktion)
weist dem Container einen Wertebereich zu
(öffentliche Elementfunktion)
gibt den zugeordneten Allokator zurück
(öffentliche Elementfunktion)
Elementzugriff
greift auf spezifisches Element mit Grenzprüfung zu
(öffentliche Elementfunktion)
greift auf spezifisches Element zu
(öffentliche Elementfunktion)
Zugriff auf das erste Element
(öffentliche Elementfunktion)
Zugriff auf das letzte Element
(öffentliche Elementfunktion)
Iteratoren
gibt einen Iterator zum Anfang zurück
(öffentliche Elementfunktion)
(C++11)
gibt einen Iterator zum Ende zurück
(öffentliche Elementfunktion)
gibt einen Reverse-Iterator zum Anfang zurück
(öffentliche Member-Funktion)
(C++11)
gibt einen Reverse-Iterator zum Ende zurück
(öffentliche Member-Funktion)
Kapazität
prüft, ob der Container leer ist
(öffentliche Elementfunktion)
gibt die Anzahl der Elemente zurück
(öffentliche Elementfunktion)
gibt die maximal mögliche Anzahl von Elementen zurück
(öffentliche Elementfunktion)
reduziert Speicherverbrauch durch Freigabe ungenutzten Speichers
(öffentliche Elementfunktion)
Modifikatoren
löscht den Inhalt
(öffentliche Elementfunktion)
fügt Elemente ein
(öffentliche Elementfunktion)
fügt eine Reihe von Elementen ein
(öffentliche Elementfunktion)
(C++11)
Konstruiert Element direkt
(öffentliche Elementfunktion)
löscht Elemente
(öffentliche Elementfunktion)
fügt ein Element am Ende hinzu
(öffentliche Elementfunktion)
Konstruiert ein Element direkt am Ende
(öffentliche Elementfunktion)
fügt eine Reihe von Elementen am Ende hinzu
(öffentliche Elementfunktion)
entfernt das letzte Element
(öffentliche Elementfunktion)
fügt ein Element am Anfang ein
(öffentliche Elementfunktion)
Konstruiert ein Element direkt am Anfang
(öffentliche Elementfunktion)
fügt eine Reihe von Elementen am Anfang hinzu
(öffentliche Elementfunktion)
entfernt das erste Element
(öffentliche Elementfunktion)
ändert die Anzahl der gespeicherten Elemente
(öffentliche Elementfunktion)
tauscht die Inhalte aus
(öffentliche Elementfunktion)

Nicht-Member-Funktionen

(entfernt in C++20) (entfernt in C++20) (entfernt in C++20) (entfernt in C++20) (entfernt in C++20) (C++20)
vergleicht zwei deque -Werte lexikographisch
(Funktionstemplate)
spezialisiert den std::swap -Algorithmus
(Funktionstemplate)
löscht alle Elemente, die bestimmte Kriterien erfüllen
(Funktionstemplate)

Deduktionsleitfäden

(seit C++17)

Hinweise

Feature-Test Makro Wert Std Feature
__cpp_lib_containers_ranges 202202L (C++23) Ranges-Konstruktion und -Einfügung für Container
__cpp_lib_constexpr_deque 202502L (C++26) constexpr std::deque

Beispiel

#include <deque>
#include <iostream>
int main()
{
    // Erstelle eine Deque mit Ganzzahlen
    std::deque<int> d = {7, 5, 16, 8};
    // Füge eine Ganzzahl am Anfang und Ende der Deque hinzu
    d.push_front(13);
    d.push_back(25);
    // Iteriere und gebe Werte der Deque aus
    for (int n : d)
        std::cout << n << ' ';
    std::cout << '\n';
}

Ausgabe:

13 7 5 16 8 25

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 230 C++98 T war nicht erforderlich, CopyConstructible zu sein
(ein Element vom Typ T könnte möglicherweise nicht konstruiert werden)
T muss ebenfalls
CopyConstructible sein

Siehe auch

passt einen Container an, um eine Warteschlange (FIFO-Datenstruktur) bereitzustellen
(Klassentemplate)