`deque`-Klasse

Artikel
10/12/2023

Ordnet Elemente eines angegebenen Typs in einer linearen Anordnung an, und aktiviert, wie ein Vektor, schnellen zufälligen Zugriff auf jedes Element sowie effizientes Einfügen und Löschen auf der Rückseite des Containers. Im Gegensatz zu einem Vektor, unterstützt die deque-Klasse allerdings auch das effiziente Einfügen und Löschen im Vordergrund des Containers.

Syntax

template <class Type, class Allocator =allocator<Type>>
class deque

Parameter

Type
Der in deque zu speichernde Elementdatentyp.

Allocator
Der Typ, der das gespeicherte Allocatorobjekt darstellt, das Details zur dequeZuordnung und Zuordnung des Speichers kapselt. Dieses Argument ist optional, und der Standardwert ist allocator<Type>.

Hinweise

Die Auswahl des Containertyps sollte im Allgemeinen auf Grundlage des für die Anwendung erforderlichen Suchen und Einfügetyps erfolgen. Vectors sollte der bevorzugte Container für die Verwaltung einer Sequenz sein, wenn der zufällige Zugriff auf jedes Element zu einem Premium-Element erfolgt und Einfügungen oder Löschungen von Elementen nur am Ende einer Sequenz erforderlich sind. Die Leistung des list-Containers ist optimal, wenn Elemente konstant an jeder Stelle innerhalb der Sequenz effizient eingefügt und gelöscht werden können. Solche Vorgänge in der Mitte der Sequenz benötigen Elementkopien und -Zuweisungen, die zur Anzahl von Elementen in der Sequenz proportional sind (lineare Zeit).

Deque Die Neuverteilung tritt auf, wenn eine Memberfunktion Elemente der Sequenz einfügen oder löschen muss:

Wenn ein Element in eine leere Sequenz eingefügt wird oder ein Element gelöscht wird, um eine leere Sequenz zu verlassen, werden iteratoren früher zurückgegeben begin und end ungültig.
Wenn ein Element an der ersten Position des dequeElements eingefügt wird, werden alle Iteratoren, aber keine Verweise, die vorhandene Elemente kennzeichnen, ungültig.
Wenn am Ende des dequeElements ein Element eingefügt wird, end werden alle Iteratoren, aber keine Verweise, die vorhandene Elemente kennzeichnen, ungültig.
Wenn ein Element am Anfang des dequeElements gelöscht wird, werden nur dieses Iterator und Verweise auf das gelöschte Element ungültig.
Wenn das letzte Element vom Ende des dequeElements gelöscht wird, wird nur dieses Iterator auf das endgültige Element und Verweise auf das gelöschte Element ungültig.

Andernfalls werden alle Iteratoren und Verweise durch das Einfügen und Löschen eines Elements und ungültig.

Member

Konstruktoren

Name Beschreibung

deque Erstellt ein Objekt vom Typ deque. Es werden mehrere Konstruktoren bereitgestellt, um den Inhalt des Neuen deque auf unterschiedliche Weise einzurichten: leer; geladen mit einer bestimmten Anzahl leerer Elemente; Inhalte, die aus einem anderen dequeverschoben oder kopiert wurden; Inhalte, die mit einem Iterator kopiert oder verschoben wurden, und ein Element, das in die dequecount Zeiten kopiert wurde. Einige der Konstruktoren ermöglichen die Verwendung eines benutzerdefinierten allocator zum Erstellen von Elementen.

Name	Beschreibung
`deque`	Erstellt ein Objekt vom Typ `deque`. Es werden mehrere Konstruktoren bereitgestellt, um den Inhalt des Neuen `deque` auf unterschiedliche Weise einzurichten: leer; geladen mit einer bestimmten Anzahl leerer Elemente; Inhalte, die aus einem anderen `deque`verschoben oder kopiert wurden; Inhalte, die mit einem Iterator kopiert oder verschoben wurden, und ein Element, das in die `dequecount` Zeiten kopiert wurde. Einige der Konstruktoren ermöglichen die Verwendung eines benutzerdefinierten `allocator` zum Erstellen von Elementen.

TypeDefs

Name	Beschreibung
`allocator_type`	Ein Typ, der die `allocator`-Klassentyp für das `deque`-Objekt darstellt.
`const_iterator`	Ein Typ, der einen Iterator mit zufälligem Zugriff bereitstellt, mit dem auf Elemente in der `deque` als `const` zugegriffen, und mit dem diese Elemente gelesen werden können.
`const_pointer`	Ein Typ, der einen Zeiger auf ein Element in einem `deque` As `const`bereitstellt.
`const_reference`	Ein Typ, der einen Verweis auf ein Element in einer `deque` zum Lesen und anderen Vorgängen als `const`.
`const_reverse_iterator`	Ein Typ, der einen Iterator mit zufälligem Zugriff bereitstellt, mit dem auf Elemente in der `deque` als `const` zugegriffen, und mit dem diese Elemente gelesen werden können. Dies `deque` wird umgekehrt angezeigt. Weitere Informationen finden Sie unter `reverse_iterator` "Klasse"
`difference_type`	Ein Typ, der den Unterschied zwischen zwei Iteratoren mit zufälligem Zugriff, die auf Elemente in derselben `deque` verweisen, bereitstellt.
`iterator`	Ein Typ, der einen Iterator mit zufälligem Zugriff bereitstellt, mit dem jedes Element in einer `deque` gelesen oder geändert werden kann.
`pointer`	Ein Typ, der einen Zeiger auf ein Element in einer `deque` bereitstellt.
`reference`	Ein Typ, der einen Verweis auf ein in einer `deque` gespeichertes Element bereitstellt.
`reverse_iterator`	Ein Typ, der einen Iterator mit zufälligem Zugriff bereitstellt, mit dem ein Element in einer `deque` gelesen oder geändert werden kann. Die `deque` Wird in umgekehrter Reihenfolge angezeigt.
`size_type`	Ein Typ, der die Anzahl von Elementen in einer `deque` zählt.
`value_type`	Ein Typ, der den in einer `deque` gespeicherten Datentyp darstellt.

Functions

Name	Beschreibung
`assign`	Löscht Elemente aus einer `deque` und kopiert eine neue Sequenz von Elementen in die Ziel-`deque`.
`at`	Gibt einen Verweis auf das Element an einer angegebenen Position in der `deque` zurück.
`back`	Gibt einen Verweis auf das letzte Element der `deque` zurück.
`begin`	Gibt ein Iterator mit zufälligem Zugriff zurück, der das erste Element in der `deque` adressiert.
`cbegin`	Gibt einen `const` Iterator an das erste Element in der .`deque`
`cend`	Gibt einen `const`-Iterator mit zufälligem Zugriff zurück, der auf eine Position unmittelbar nach dem Ende der `deque` verweist.
`clear`	Löscht alle Elemente einer `deque` auf.
`crbegin`	Gibt einen Iterator für zufälligen Zugriff `const` auf das erste Element in umgekehrter `deque` Reihenfolge zurück.
`crend`	Gibt einen Iterator für zufälligen Zugriff `const` auf das erste Element in umgekehrter `deque` Reihenfolge zurück.
`emplace`	Fügt ein direkt konstruiertes Element an einer angegebenen Position in die `deque` ein.
`emplace_back`	Fügt ein direkt konstruiertes Element am Ende der `deque` ein.
`emplace_front`	Fügt ein direkt konstruiertes Element am Anfang der `deque` ein.
`empty`	Gibt `true` zurück, wenn `deque` keine Elemente enthält, und gibt `false` zurück, wenn mindestens ein Element enthält.
`end`	Gibt einen Iterator mit zufälligem Zugriff zurück, der auf eine Position unmittelbar nach dem Ende der `deque` verweist.
`erase`	Entfernt ein Element oder eine Reihe von Elementen in einer `deque` aus angegebenen Speicherorten.
`front`	Gibt einen Verweis auf das erste Element in einer `deque` zurück.
`get_allocator`	Gibt eine Kopie des zum Erstellen der `allocator` verwendeten `deque`-Objekts zurück.
`insert`	Fügt ein Element, mehrere Elemente oder einen Reihe von Elementen an einer angegebenen Position in die `deque` ein.
`max_size`	Gibt die mögliche Maximallänge der `deque` zurück.
`pop_back`	Löscht das Element am Ende der `deque`.
`pop_front`	Löscht das Element am Anfang der `deque`.
`push_back`	Fügt am Ende der `deque` ein Element hinzu.
`push_front`	Fügt am Anfang der `deque` ein Element hinzu.
`rbegin`	Gibt dem ersten Element einen Iterator mit zufälligem Zugriff in umgekehrter `deque` zurück.
`rend`	Gibt einen Iterator mit zufälligem Zugriff zurück, der grade über das letzte Element in einer umgekehrten `deque` zeigt.
`resize`	Gibt eine neue Größe für eine `deque` an.
`shrink_to_fit`	Verwirft Überkapazität.
`size`	Gibt die Anzahl von Elementen in der `deque` zurück.
`swap`	Tauscht die Elemente zweier `deque`n.

Operatoren

Name	Beschreibung
`operator[]`	Gibt einen Verweis auf das `deque`-Element an einer angegebenen Position zurück.
`operator=`	Ersetzt die Elemente der `deque` mit einer Kopie einer anderen `deque`.

`allocator_type`

Ein Typ, der die Allocator-Klasse für das deque Objekt darstellt.

typedef Allocator allocator_type;

Hinweise

allocator_type ist ein Synonym für den Vorlagenparameter Allocator.

Beispiel

Ein Beispiel hierfür finden Sie unter get_allocator.

`assign`

Löscht Elemente aus einem deque Element und kopiert eine neue Gruppe von Elementen in das Ziel deque.

template <class InputIterator>
void assign(
    InputIterator First,
    InputIterator Last);

void assign(
    size_type Count,
    const Type& Val);

void assign(initializer_list<Type> IList);

Parameter

First
Position des ersten Elements im Bereich der Elemente, die aus dem Argument dequekopiert werden sollen.

Last
Position des ersten Elements über den Bereich der Elemente hinaus, die aus dem Argument dequekopiert werden sollen.

Count
Die Anzahl der Kopien eines Elements, das in das dequeElement eingefügt wird.

Val
Der Wert des Elements, das in den deque eingefügt wird.

IList
Das initializer_list in die deque.

Hinweise

Nachdem vorhandene Elemente im Ziel deque gelöscht wurden, assign fügt entweder einen angegebenen Elementbereich aus dem Original deque oder von einem anderen deque in das Ziel dequeein, oder fügt Kopien eines neuen Elements eines angegebenen Werts in das Ziel dequeein.

Beispiel

// deque_assign.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <initializer_list>

int main()
{
    using namespace std;
    deque <int> c1, c2;
    deque <int>::const_iterator cIter;

    c1.push_back(10);
    c1.push_back(20);
    c1.push_back(30);
    c2.push_back(40);
    c2.push_back(50);
    c2.push_back(60);

    deque<int> d1{ 1, 2, 3, 4 };
    initializer_list<int> iList{ 5, 6, 7, 8 };
    d1.assign(iList);

    cout << "d1 = ";
    for (int i : d1)
        cout << i;
    cout << endl;

    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(++c2.begin(), c2.end());
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(7, 4);
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;
}

d1 = 5678c1 =102030c1 =5060c1 =4444444

`at`

Gibt einen Verweis auf das Element an einer angegebenen Position in der deque zurück.

reference at(size_type pos);

const_reference at(size_type pos) const;

Parameter

pos
Die tiefgestellte (oder Positionsnummer) des Elements, auf das dequeverwiesen werden soll.

Rückgabewert

Wenn pos die Größe des dequeWerts größer ist, at wird eine Ausnahme ausgelöst.

Hinweise

Wenn der Rückgabewert at eines const_referenceObjekts zugewiesen ist, kann das deque Objekt nicht geändert werden. Wenn der Rückgabewert at eines referenceObjekts zugewiesen ist, kann das deque Objekt geändert werden.

Beispiel

// deque_at.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const int& i = c1.at( 0 );
   int& j = c1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`back`

Gibt einen Verweis auf das letzte Element der deque zurück.

reference back();
const_reference back() const;

Rückgabewert

Das letzte Element der deque. Wenn dies deque leer ist, ist der Rückgabewert nicht definiert.

Hinweise

Wenn der Rückgabewert back eines const_referenceObjekts zugewiesen ist, kann das deque Objekt nicht geändert werden. Wenn der Rückgabewert back eines referenceObjekts zugewiesen ist, kann das deque Objekt geändert werden.

Bei der Kompilierung mithilfe _ITERATOR_DEBUG_LEVEL von 1 oder 2 tritt ein Laufzeitfehler auf, wenn Sie versuchen, auf ein Element in einem leeren dequeElement zuzugreifen. Weitere Informationen finden Sie unter Checked Iterators .

Beispiel

// deque_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

   int& i = c1.back( );
   const int& ii = c1.front( );

   cout << "The last integer of c1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of c1 is " << ii << endl;
}

The last integer of c1 is 11
The next-to-last integer of c1 is 10

`begin`

Gibt ein Iterator zurück, der das erste Element im deque-Element adressiert.

const_iterator begin() const;
iterator begin();

Rückgabewert

Ein Iterator mit direktem Zugriff, der das erste Element im deque adressiert oder auf die Position zeigt, der auf einen leeren deque folgt.

Hinweise

Wenn der Rückgabewert begin eines const_iteratorObjekts zugewiesen ist, kann das deque Objekt nicht geändert werden. Wenn der Rückgabewert begin eines iteratorObjekts zugewiesen ist, kann das deque Objekt geändert werden.

Beispiel

// deque_begin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::const_iterator c1_cIter;

   c1.push_back( 1 );
   c1.push_back( 2 );

   c1_Iter = c1.begin( );
   cout << "The first element of c1 is " << *c1_Iter << endl;

*c1_Iter = 20;
   c1_Iter = c1.begin( );
   cout << "The first element of c1 is now " << *c1_Iter << endl;

   // The following line would be an error because iterator is const
   // *c1_cIter = 200;
}

The first element of c1 is 1
The first element of c1 is now 20

`cbegin`

Gibt einen const-Iterator zurück, mit dem das erste Element im Bereich behandelt wird.

const_iterator cbegin() const;

Rückgabewert

Ein const-Random-Access-Iterator, der auf das erste Element des Bereichs zeigt oder die Position direkt hinter dem Ende eines leeren Bereichs (für einen leeren Bereich gilt cbegin() == cend()).

Hinweise

Mit dem Rückgabewert von cbegin, die Elemente im Bereich können nicht geändert werden.

Sie können diese Memberfunktion anstelle der begin()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. Normalerweise wird sie in Verbindung mit dem auto Typabzug Schlüsselwort (keyword) verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der begin() und cbegin() unterstützt.

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines Bereichs unmittelbar nachfolgt.

const_iterator cend() const;

Rückgabewert

Ein Random-Access-Iterator, der auf eine Position unmittelbar nach dem Ende des Bereichs verweist.

Hinweise

cend wird verwendet, um zu testen, ob ein Iterator das Ende seines Bereichs übergeben hat.

Sie können diese Memberfunktion anstelle der end()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. Normalerweise wird sie in Verbindung mit dem auto Typabzug Schlüsselwort (keyword) verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der end() und cend() unterstützt.

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Der zurückgegebene cend Wert sollte nicht abgeleitet werden.

`clear`

Löscht alle Elemente einer deque auf.

void clear();

Beispiel

// deque_clear.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   cout << "The size of the deque is initially " << c1.size( ) << endl;
   c1.clear( );
   cout << "The size of the deque after clearing is " << c1.size( ) << endl;
}

The size of the deque is initially 3
The size of the deque after clearing is 0

`const_iterator`

Ein Typ, der einen Iterator mit wahlfreiem Zugriff bereitstellt, der auf ein const Element in der Datei dequezugreifen und diese lesen kann.

typedef implementation-defined const_iterator;

Hinweise

Ein Typ const_iterator kann nicht verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

Ein Beispiel hierfür finden Sie unter back.

`const_pointer`

Stellt einen Zeiger auf ein const Element in einem deque.

typedef typename Allocator::const_pointer const_pointer;

Hinweise

Ein Typ const_pointer kann nicht verwendet werden, um den Wert eines Elements zu ändern. Ein iterator Element wird häufiger verwendet, um auf ein deque Element zuzugreifen.

`const_reference`

Ein Typ, der einen Verweis auf ein const-Element bereitstellt, das in einem deque-Element zum Lesen und Ausführen von const-Vorgängen gespeichert ist.

typedef typename Allocator::const_reference const_reference;

Hinweise

Ein Typ const_reference kann nicht verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

// deque_const_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const deque <int> c2 = c1;
   const int &i = c2.front( );
   const int &j = c2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as c2 is const
   // c2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

Ein Typ, der einen Iterator mit wahlfreiem Zugriff bereitstellt, der alle const Elemente in der dequeDatei lesen kann.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Hinweise

Ein Typ const_reverse_iterator kann den Wert eines Elements nicht ändern und wird zum Durchlaufen des deque umgekehrten Elements verwendet.

Beispiel

Ein Beispiel zum Deklarieren und Verwenden eines Iterators finden Sie im Beispiel rbegin .

`crbegin`

Gibt einen const Iterator an das erste Element in einem umgekehrten dequeElement zurück.

const_reverse_iterator crbegin() const;

Rückgabewert

Ein umgekehrter const Iterator für den zufälligen Zugriff, der das erste Element in einem umgekehrten deque Element adressiert oder angibt, was das letzte Element in der unreversierten deque.

Hinweise

Mit dem Rückgabewert des crbeginObjekts kann das deque Objekt nicht geändert werden.

Beispiel

// deque_crbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::iterator v1_Iter;
   deque <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of deque is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed deque is "
        << *v1_rIter << "." << endl;
}

The first element of deque is 1.
The first element of the reversed deque is 2.

`crend`

Gibt einen const Iterator zurück, der die Position adressiert, die das letzte Element in einem umgekehrten Element erfolgreich war deque.

const_reverse_iterator crend() const;

Rückgabewert

Ein umgekehrter const Iterator für den zufälligen Zugriff, der die Position adressiert, die das letzte Element in einem umgekehrten deque Element erfolgreich war (die Position, die dem ersten Element in der nicht reversierten dequeSeite vorausging).

Hinweise

crend wird mit einem umgekehrten deque verwendet, genau wie array::cend bei einem deque.

Mit dem Rückgabewert ( crend entsprechend dekrementiert) kann das deque Objekt nicht geändert werden.

crend kann verwendet werden, um zu testen, ob das Ende der deque von einem umgekehrten Iterator erreicht wurde.

Der zurückgegebene crend Wert sollte nicht abgeleitet werden.

Beispiel

// deque_crend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`deque`

Erstellt eine deque bestimmte Größe oder mit Elementen eines bestimmten Werts oder mit einem bestimmten Zuweisungselement oder als Kopie aller oder eines Teils eines anderen dequeWerts.

deque();

explicit deque(const Allocator& Al);
explicit deque(size_type Count);
deque(size_type Count, const Type& Val);

deque(
    size_type Count,
    const Type& Val,
    const Allocator& Al);

deque(const deque& Right);

template <class InputIterator>
deque(InputIterator First,  InputIterator Last);

template <class InputIterator>
deque(
   InputIterator First,
   InputIterator Last,
   const Allocator& Al);

deque(initializer_list<value_type> IList, const Allocator& Al);

Parameter

Al
Die mit diesem Objekt zu verwendende Zuweisungsklasse.

Count
Die Anzahl der Elemente im konstruierten deque.

Val
Der Wert der Elemente im konstruierten deque.

Right
Das deque-Element, von dem das erstellte deque-Element eine Kopie sein soll.

First
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

Last
Die Position des ersten Elements nach dem zu kopierenden Elementbereich.

IList
Das zu kopierende initializer_list.

Hinweise

Alle Konstruktoren speichern ein Allocator-Objekt (Al) und initialisieren die deque.

Die ersten beiden Konstruktoren geben eine leere Initiale dequean; die zweite gibt auch den zu verwendenden Allocatortyp (_Al) an.

Der dritte Konstruktor gibt eine Wiederholung einer angegebenen Anzahl (count) von Elementen des Standardwerts für die Klasse Type an.

Die vierten und fünften Konstruktoren geben eine Wiederholung von (Count) Elementen des Werts valan.

Der sechste Konstruktor gibt eine Kopie der dequeRight.

Der siebte und achte Konstruktor kopieren den Bereich [First, Last) eines deque.

Der siebte Konstruktor verschiebt den dequeRight.

Der achte Konstruktor kopiert den Inhalt eines initializer_list.

Keine der Konstruktoren führen Zwischenneuzuordnungen aus.

Beispiel

/ compile with: /EHsc
#include <deque>
#include <iostream>
#include <forward_list>

int main()
{
    using namespace std;

    forward_list<int> f1{ 1, 2, 3, 4 };

    f1.insert_after(f1.begin(), { 5, 6, 7, 8 });

    deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

    // Create a deque c1 with 3 elements of default value 0
    deque <int> c1(3);

    // Create a deque c2 with 5 elements of value 2
    deque <int> c2(5, 2);

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3(3, 1, c2.get_allocator());

    // Create a copy, deque c4, of deque c2
    deque <int> c4(c2);

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    deque <int> c5(c4.begin(), c4_Iter);

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    c4_Iter++;
    deque <int> c6(c4.begin(), c4_Iter, c2.get_allocator());

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

    initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for (int i : c1)
        cout << i << " ";
    cout << endl;

    cout << "c2 = ";
    for (int i : c2)
        cout << i << " ";
    cout << endl;

    cout << "c3 = ";
    for (int i : c3)
        cout << i << " ";
    cout << endl;

    cout << "c4 = ";
    for (int i : c4)
        cout << i << " ";
    cout << endl;

    cout << "c5 = ";
    for (int i : c5)
        cout << i << " ";
    cout << endl;

    cout << "c6 = ";
    for (int i : c6)
        cout << i << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7(move(c6));
    deque <int>::iterator c7_Iter;

    cout << "c7 =";
    for (int i : c7)
        cout << i << " ";
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    for (int i : c9)
        cout << i << " ";
    cout << endl;

    int x = 3;
}
// deque_deque.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
    using namespace std;
   deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

    // Create a deque c1 with 3 elements of default value 0
    deque <int> c1( 3 );

    // Create a deque c2 with 5 elements of value 2
    deque <int> c2( 5, 2 );

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3( 3, 1, c2.get_allocator( ) );

    // Create a copy, deque c4, of deque c2
    deque <int> c4( c2 );

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin( );
    c4_Iter++;
    c4_Iter++;
    deque <int> c5( c4.begin( ), c4_Iter );

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin( );
   c4_Iter++;
   c4_Iter++;
   c4_Iter++;
   deque <int> c6( c4.begin( ), c4_Iter, c2.get_allocator( ) );

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

        initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
        cout << *c1_Iter << " ";
    cout << endl;

    cout << "c2 = ";
    for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
        cout << *c2_Iter << " ";
    cout << endl;

    cout << "c3 = ";
    for ( c3_Iter = c3.begin( ); c3_Iter != c3.end( ); c3_Iter++ )
        cout << *c3_Iter << " ";
    cout << endl;

    cout << "c4 = ";
    for ( c4_Iter = c4.begin( ); c4_Iter != c4.end( ); c4_Iter++ )
        cout << *c4_Iter << " ";
    cout << endl;

    cout << "c5 = ";
    for ( c5_Iter = c5.begin( ); c5_Iter != c5.end( ); c5_Iter++ )
        cout << *c5_Iter << " ";
    cout << endl;

    cout << "c6 = ";
    for ( c6_Iter = c6.begin( ); c6_Iter != c6.end( ); c6_Iter++ )
        cout << *c6_Iter << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7( move(c6) );
    deque <int>::iterator c7_Iter;

    cout << "c7 =" ;
    for ( c7_Iter = c7.begin( ) ; c7_Iter != c7.end( ) ; c7_Iter++ )
        cout << " " << *c7_Iter;
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    or (int i : c9)
        cout << i << " ";
    cout << endl;
}

`difference_type`

Ein Typ, der den Unterschied zwischen zwei Iteratoren, die auf Elemente innerhalb derselben deque verweisen, bereitstellt.

typedef typename Allocator::difference_type difference_type;

Hinweise

Ein difference_type kann auch als die Anzahl der Elemente zwischen zwei Zeigern beschrieben werden.

Beispiel

// deque_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <deque>
#include <algorithm>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   deque <int>::difference_type df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

Fügt ein direkt konstruiertes Element an einer angegebenen Position in die deque ein.

iterator emplace(
    const_iterator _Where,
    Type&& val);

Parameter

_Where
Die Position, an der deque das erste Element eingefügt wird.

val
Der Wert des Elements, das in den deque eingefügt wird.

Rückgabewert

Die Funktion gibt einen Iterator zurück, der auf den Speicherort zeigt, an dem das neue Element in den deque eingefügt wurde.

Hinweise

Einfügevorgänge können sehr speicherintensiv sein. Eine Abhandlung zur Leistung von deque finden Sie unter deque.

Beispiel

// deque_emplace.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
vv1[0] = 10 20 30

`emplace_back`

Fügt ein direkt konstruiertes Element am Ende der deque ein.

void emplace_back(Type&& val);

Parameter

val
Das Element, das am Ende der deque hinzugefügt wird.

Beispiel

// deque_emplace_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_back( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`emplace_front`

Fügt ein direkt konstruiertes Element am Ende der deque ein.

void emplace_front(Type&& val);

Parameter

val
Das Element, das am Anfang der deque.

Beispiel

// deque_emplace_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_front( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`empty`

Testet, ob ein deque-Element leer ist.

bool empty() const;

Rückgabewert

true wenn die deque leer ist; false wenn dies deque nicht leer ist.

Beispiel

// deque_empty.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   if ( c1.empty( ) )
      cout << "The deque is empty." << endl;
   else
      cout << "The deque is not empty." << endl;
}

The deque is not empty.

`end`

Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element einem deque-Element nachfolgt.

const_iterator end() const;

iterator end();

Rückgabewert

Ein Iterator mit wahlfreiem Zugriff, der den Speicherort adressiert, der das letzte Element in einem deque. Wenn die deque leer ist, gilt anschließend deque::end == deque::begin.

Hinweise

end wird verwendet, um zu testen, ob ein Iterator das Ende seines deque erreicht hat.

Beispiel

// deque_end.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_Iter = c1.end( );
   c1_Iter--;
   cout << "The last integer of c1 is " << *c1_Iter << endl;

   c1_Iter--;
   *c1_Iter = 400;
   cout << "The new next-to-last integer of c1 is " << *c1_Iter << endl;

   // If a const iterator had been declared instead with the line:
   // deque <int>::const_iterator c1_Iter;
   // an error would have resulted when inserting the 400

   cout << "The deque is now:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
}

The last integer of c1 is 30
The new next-to-last integer of c1 is 400
The deque is now: 10 400 30

`erase`

Entfernt ein Element oder eine Reihe von Elementen in einer deque aus angegebenen Speicherorten.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Parameter

_Where
Die Position des Elements, das aus dem dequeElement entfernt werden soll.

first
Position des ersten Elements, das aus dem deque.

last
Position direkt über dem letzten Element entfernt aus dem deque.

Rückgabewert

Ein Iterator mit wahlfreiem Zugriff, der das erste Element neu angibt Standard, das über alle entfernten Elemente hinausgeht, oder ein Zeiger auf das Ende des deque Elements, wenn kein solches Element vorhanden ist.

Hinweise

erase löst nie eine Ausnahme aus.

Beispiel

// deque_erase.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 40 );
   c1.push_back( 50 );
   cout << "The initial deque is: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   c1.erase( c1.begin( ) );
   cout << "After erasing the first element, the deque becomes:  ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   Iter = c1.begin( );
   Iter++;
   c1.erase( Iter, c1.end( ) );
   cout << "After erasing all elements but the first, deque becomes: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
}

The initial deque is: 10 20 30 40 50
After erasing the first element, the deque becomes:  20 30 40 50
After erasing all elements but the first, deque becomes: 20

`front`

Gibt einen Verweis auf das erste Element in einer deque zurück.

reference front();

const_reference front() const;

Rückgabewert

Wenn dies deque leer ist, ist die Rückgabe nicht definiert.

Hinweise

Wenn der Rückgabewert front eines const_referenceObjekts zugewiesen ist, kann das deque Objekt nicht geändert werden. Wenn der Rückgabewert front eines referenceObjekts zugewiesen ist, kann das deque Objekt geändert werden.

Beispiel

// deque_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

   int& i = c1.front( );
   const int& ii = c1.front( );

   cout << "The first integer of c1 is " << i << endl;
   i++;
   cout << "The second integer of c1 is " << ii << endl;
}

The first integer of c1 is 10
The second integer of c1 is 11

`get_allocator`

Gibt eine Kopie des allocator -Objekts zurück, das zum Erstellen des dequeObjekts verwendet wird.

Allocator get_allocator() const;

Rückgabewert

Der von der dequeZuweisung verwendete Allokator .

Hinweise

Allocators für die deque Klasse geben an, wie die Klasse Speicher verwaltet. Für die meisten Programmieranforderungen reichen die standardmäßigen allocator-Objekte mit Container-Klassen der C++-Standardbibliothek aus. Schreiben und Verwenden Ihrer eigener Zuweisungsklasse ist ein C++ -Thema für Fortgeschrittene.

Beispiel

// deque_get_allocator.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   deque <int> c1;
   deque <int, allocator<int> > c2 = deque <int, allocator<int> >( allocator<int>( ) );

   // c3 will use the same allocator class as c1
   deque <int> c3( c1.get_allocator( ) );

   deque <int>::allocator_type xlst = c1.get_allocator( );
   // You can now call functions on the allocator class used by c1
}

`insert`

Fügt ein Element oder eine Reihe von Elementen oder einen Bereich von Elementen an der deque angegebenen Position ein.

iterator insert(
    const_iterator Where,
    const Type& Val);

iterator insert(
    const_iterator Where,
    Type&& Val);

void insert(
    iterator Where,
    size_type Count,
    const Type& Val);

template <class InputIterator>
void insert(
    iterator Where,
    InputIterator First,
    InputIterator Last);

iterator insert(
    iterator Where,initializer_list<Type>
IList);

Parameter

Where
Die Position im Ziel deque , an der das erste Element eingefügt wird.

Val
Der Wert des Elements, das in den deque eingefügt wird.

Count
Die Anzahl der Elemente, die in die deque.

First
Die Position des ersten Elements im Bereich von Elementen im Argument deque , das kopiert werden soll.

Last
Die Position des ersten Elements über den Bereich von Elementen im Argument deque hinaus, das kopiert werden soll.

IList
Die initializer_list einzufügenden Elemente.

Rückgabewert

Die ersten beiden Einfügefunktionen geben einen Iterator zurück, der auf die Position zeigt, an der das neue Element in die dequeEinfügemarke eingefügt wurde.

Hinweise

Jeder Einfügevorgang kann ressourcenintensiv sein.

`iterator`

Ein Typ, der einen Iterator mit zufälligem Zugriff bereitstellt, mit dem jedes Element in einer deque gelesen oder geändert werden kann.

typedef implementation-defined iterator;

Hinweise

Ein Typ iterator kann verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

Ein Beispiel hierfür finden Sie unter begin.

`max_size`

Gibt die Maximallänge der deque zurück.

size_type max_size() const;

Rückgabewert

Die maximal mögliche Länge der deque.

Beispiel

// deque_max_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   i = c1.max_size( );
   cout << "The maximum possible length of the deque is " << i << "." << endl;
}

`operator[]`

Gibt einen Verweis auf das deque-Element an einer angegebenen Position zurück.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Parameter

pos
Die Position des deque elements, auf das verwiesen werden soll.

Rückgabewert

Ein Verweis auf das Element, dessen Position im Argument angegeben wird. Wenn die angegebene Position größer als die Größe des dequeBereichs ist, ist das Ergebnis nicht definiert.

Hinweise

Wenn der Rückgabewert operator[] eines const_referenceObjekts zugewiesen ist, kann das deque Objekt nicht geändert werden. Wenn der Rückgabewert operator[] eines referenceObjekts zugewiesen ist, kann das deque Objekt geändert werden.

Bei der Kompilierung mithilfe von _ITERATOR_DEBUG_LEVEL 1 oder 2 tritt ein Laufzeitfehler auf, wenn Sie versuchen, auf ein Element außerhalb der Grenzen der .deque Weitere Informationen finden Sie unter Checked Iterators .

Beispiel

// deque_op_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   cout << "The first integer of c1 is " << c1[0] << endl;
   int& i = c1[1];
   cout << "The second integer of c1 is " << i << endl;
}

The first integer of c1 is 10
The second integer of c1 is 20

`operator=`

Ersetzt die Elemente dieser deque Elemente mithilfe der Elemente aus einem anderen deque.

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Parameter

right
Dies deque stellt den neuen Inhalt bereit.

Hinweise

Die erste Außerkraftsetzung kopiert Elemente in rightdiese deque aus , der Quelle der Zuordnung. Die zweite Außerkraftsetzung verschiebt Elemente von deque diesem Element.right

Elemente, die in diesem deque Element enthalten sind, bevor der Operator ausgeführt wird, werden entfernt.

Beispiel

// deque_operator_as.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
using namespace std;

typedef deque<int> MyDeque;

template<typename MyDeque> struct S;

template<typename MyDeque> struct S<MyDeque&> {
  static void show( MyDeque& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
    cout << endl;
  }
};

template<typename MyDeque> struct S<MyDeque&&> {
  static void show( MyDeque&& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
cout << " via unnamed rvalue reference " << endl;
  }
};

int main( )
{
   MyDeque d1, d2;

   d1.push_back(10);
   d1.push_back(20);
   d1.push_back(30);
   d1.push_back(40);
   d1.push_back(50);

   cout << "d1 = " ;
   S<MyDeque&>::show( d1 );

   d2 = d1;
   cout << "d2 = ";
   S<MyDeque&>::show( d2 );

   cout << "     ";
   S<MyDeque&&>::show ( move< MyDeque& > (d1) );
}

`pointer`

Stellt einen Zeiger auf ein Element in einem deque.

typedef typename Allocator::pointer pointer;

Hinweise

Ein Typ pointer kann verwendet werden, um den Wert eines Elements zu ändern. Ein iterator Element wird häufiger verwendet, um auf ein deque Element zuzugreifen.

`pop_back`

Löscht das Element am Ende der .deque

void pop_back();

Hinweise

Das letzte Element darf nicht leer sein. pop_back löst nie eine Ausnahme aus.

Beispiel

// deque_pop_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The last element is: " << c1.back( ) << endl;

   c1.pop_back( );
   cout << "After deleting the element at the end of the deque, the "
      "last element is: " << c1.back( ) << endl;
}

The first element is: 1
The last element is: 2
After deleting the element at the end of the deque, the last element is: 1

`pop_front`

Löscht das Element am Anfang der deque.

void pop_front();

Hinweise

Das erste Element darf nicht leer sein. pop_front löst nie eine Ausnahme aus.

Beispiel

// deque_pop_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The second element is: " << c1.back( ) << endl;

   c1.pop_front( );
   cout << "After deleting the element at the beginning of the "
      "deque, the first element is: " << c1.front( ) << endl;
}

The first element is: 1
The second element is: 2
After deleting the element at the beginning of the `deque`, the first element is: 2

`push_back`

Fügt am Ende der deque ein Element hinzu.

void push_back(const Type& val);

void push_back(Type&& val);

Parameter

val
Das Element, das am Ende der deque hinzugefügt wird.

Hinweise

Wenn eine Ausnahme ausgelöst wird, bleibt die deque unverändert, und die Ausnahme wird erneut ausgelöst.

`push_front`

Fügt am Anfang des dequeElements ein Element hinzu.

void push_front(const Type& val);
void push_front(Type&& val);

Parameter

val
Das Element, das am Anfang der deque.

Hinweise

Wenn eine Ausnahme ausgelöst wird, bleibt die deque unverändert, und die Ausnahme wird erneut ausgelöst.

Beispiel

// deque_push_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_front( 1 );
   if ( c1.size( ) != 0 )
      cout << "First element: " << c1.front( ) << endl;

   c1.push_front( 2 );
   if ( c1.size( ) != 0 )
      cout << "New first element: " << c1.front( ) << endl;

// move initialize a deque of strings
   deque <string> c2;
   string str("a");

   c2.push_front( move( str ) );
   cout << "Moved first element: " << c2.front( ) << endl;
}

First element: 1
New first element: 2
Moved first element: a

`rbegin`

Gibt einen Iterator an das erste Element in einer umgekehrten dequeZurück.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Rückgabewert

Ein umgekehrter Iterator für den zufälligen Zugriff, der das erste Element in einem umgekehrten deque Element adressiert oder angibt, was das letzte Element in der unreversierten deque.

Hinweise

rbegin wird mit einem umgekehrten deque verwendet, genau wie begin bei einem deque.

Wenn der Rückgabewert rbegin eines const_reverse_iteratorObjekts zugewiesen ist, kann das deque Objekt nicht geändert werden. Wenn der Rückgabewert rbegin eines reverse_iteratorObjekts zugewiesen ist, kann das deque Objekt geändert werden.

Mit rbegin kann ein deque rückwärts durchlaufen werden.

Beispiel

// deque_rbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;

   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_rIter = c1.rbegin( );
   cout << "Last element in the deque is " << *c1_rIter << "." << endl;

   cout << "The deque contains the elements: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << "in that order.";
   cout << endl;

   // rbegin can be used to iterate through a deque in reverse order
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rbegin( );
   *c1_rIter = 40;  // This would have caused an error if a
                    // const_reverse iterator had been declared as
                    // noted above
   cout << "Last element in deque is now " << *c1_rIter << "." << endl;
}

Last element in the deque is 30.
The deque contains the elements: 10 20 30 in that order.
The reversed deque is: 30 20 10
Last element in deque is now 40.

`reference`

Ein Typ, der einen Verweis auf ein in einer deque gespeichertes Element bereitstellt.

typedef typename Allocator::reference reference;

Beispiel

// deque_reference.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const int &i = c1.front( );
   int &j = c1.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`rend`

Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten deque-Elements nachfolgt.

const_reverse_iterator rend() const;

reverse_iterator rend();

Rückgabewert

Ein umgekehrter Iterator für den zufälligen Zugriff, der die Position adressiert, die das letzte Element in einem umgekehrten deque Element erfolgreich war (die Position, die dem ersten Element in der nicht reversierten dequeSeite vorausging).

Hinweise

rend wird mit einem umgekehrten deque verwendet, genau wie end bei einem deque.

Wenn der Rückgabewert rend eines const_reverse_iteratorObjekts zugewiesen ist, kann das deque Objekt nicht geändert werden. Wenn der Rückgabewert rend eines reverse_iteratorObjekts zugewiesen ist, kann das deque Objekt geändert werden.

rend kann verwendet werden, um zu testen, ob ein Umgekehrter Iterator das Ende des Iterators dequeerreicht hat.

Der zurückgegebene rend Wert sollte nicht abgeleitet werden.

Beispiel

// deque_rend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;
   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_rIter = c1.rend( );
   c1_rIter --; // Decrementing a reverse iterator moves it forward
                // in the deque (to point to the first element here)
   cout << "The first element in the deque is: " << *c1_rIter << endl;

   cout << "The deque is: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << endl;

   // rend can be used to test if an iteration is through all of
   // the elements of a reversed deque
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rend( );
   c1_rIter--; // Decrementing the reverse iterator moves it backward
               // in the reversed deque (to the last element here)
   *c1_rIter = 40; // This modification of the last element would
                   // have caused an error if a const_reverse
                   // iterator had been declared (as noted above)
   cout << "The modified reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;
}

The first element in the deque is: 10
The deque is: 10 20 30
The reversed deque is: 30 20 10
The modified reversed deque is: 30 20 40

`resize`

Gibt eine neue Größe für eine deque an.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Parameter

_Newsize
Die neue Größe der deque.

val
Der Wert der neuen Elemente, die deque hinzugefügt werden sollen, wenn die neue Größe größer ist, wenn die ursprüngliche Größe größer ist. Wenn der Wert ausgelassen wird, werden dem Standardwert die neuen Elemente für die Klasse zugewiesen.

Hinweise

Wenn die dequeElemente kleiner als _Newsizesind, werden Elemente der deque Größe hinzugefügt, bis sie die Größe _Newsizeerreicht.size

Wenn die dequeElemente size größer als _Newsizesind, werden die Elemente, die am nächsten am Ende der deque Löschung liegen, gelöscht, bis die deque Größe _Newsizeerreicht ist.

Wenn die aktuelle Größe der deque Datei mit dem identisch _Newsizeist, wird keine Aktion ausgeführt.

size entspricht der aktuellen Größe der deque.

Beispiel

// deque_resize.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1.resize( 4,40 );
   cout << "The size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is " << c1.back( ) << endl;

   c1.resize( 5 );
   cout << "The size of c1 is now: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;

   c1.resize( 2 );
   cout << "The reduced size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;
}

The size of c1 is: 4
The value of the last element is 40
The size of c1 is now: 5
The value of the last element is now 0
The reduced size of c1 is: 2
The value of the last element is now 20

`reverse_iterator`

Ein Typ, der einen Iterator mit wahlfreiem Zugriff bereitstellt, der ein Element in einem umgekehrten dequeElement lesen oder ändern kann.

typedef std::reverse_iterator<iterator> reverse_iterator;

Hinweise

Ein Typ reverse_iterator wird verwendet, um die deque.

Beispiel

Ein Beispiel hierfür finden Sie unter rbegin.

`shrink_to_fit`

Verwirft Überkapazität.

void shrink_to_fit();

Hinweise

Es gibt keine tragbare Möglichkeit, festzustellen, ob shrink_to_fit der von einem deque.

Beispiel

// deque_shrink_to_fit.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   //deque <int>::iterator Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
   v1.shrink_to_fit();
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
}

Current size of v1 = 1
Current size of v1 = 1

`size`

Gibt die Anzahl von Elementen in der deque zurück.

size_type size() const;

Rückgabewert

Die aktuelle Länge des deque.

Beispiel

// deque_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   c1.push_back( 1 );
   i = c1.size( );
   cout << "The deque length is " << i << "." << endl;

   c1.push_back( 2 );
   i = c1.size( );
   cout << "The deque length is now " << i << "." << endl;
}

The deque length is 1.
The deque length is now 2.

`size_type`

Ein Typ, der die Anzahl von Elementen in einer deque zählt.

typedef typename Allocator::size_type size_type;

Beispiel

Ein Beispiel hierfür finden Sie unter size.

`swap`

Tauscht die Elemente von zwei deque-Objekten aus.

void swap(deque<Type, Allocator>& right);

friend void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right) template <class Type, class Allocator>
void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right);

Parameter

right
Die deque Bereitstellung der zu tauschenden Elemente oder deren deque Elemente sollen mit denen des dequeleftTauschs ausgetauscht werden.

left
A deque , dessen Elemente mit denen der dequerightausgetauscht werden sollen.

Beispiel

// deque_swap.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1, c2, c3;
   deque <int>::iterator c1_Iter;

   c1.push_back( 1 );
   c1.push_back( 2 );
   c1.push_back( 3 );
   c2.push_back( 10 );
   c2.push_back( 20 );
   c3.push_back( 100 );

   cout << "The original deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.swap( c2 );

   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap( c1,c3 );

   cout << "After swapping with c3, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap<>(c1, c2);
   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;
}

The original deque c1 is: 1 2 3
After swapping with c2, deque c1 is: 10 20
After swapping with c3, deque c1 is: 100
After swapping with c2, deque c1 is: 1 2 3

`value_type`

Ein Typ, der den in einer deque gespeicherten Datentyp darstellt.

typedef typename Allocator::value_type value_type;

Hinweise

value_type ist ein Synonym für den Vorlagenparameter Type.

Beispiel

// deque_value_type.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
int main( )
{
   using namespace std;
   deque<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

Siehe auch

Threadsicherheit in der C++-Standardbibliothek
C++-Standardbibliotheksreferenz

deque-Klasse

Syntax

Parameter

Hinweise

Member

Konstruktoren

TypeDefs

Functions

Operatoren

allocator_type

Hinweise

Beispiel

assign

Parameter

Hinweise

Beispiel

at

Parameter

Rückgabewert

Hinweise

Beispiel

back

Rückgabewert

Hinweise

Beispiel

begin

Rückgabewert

Hinweise

Beispiel

cbegin

Rückgabewert

Hinweise

cend

Rückgabewert

Hinweise

clear

Beispiel

const_iterator

Hinweise

Beispiel

const_pointer

Hinweise

const_reference

Hinweise

Beispiel

const_reverse_iterator

Hinweise

Beispiel

crbegin

Rückgabewert

Hinweise

Beispiel

crend

Rückgabewert

Hinweise

Beispiel

deque

Parameter

Hinweise

Beispiel

difference_type

Hinweise

Beispiel

emplace

Parameter

Rückgabewert

Hinweise

Beispiel

emplace_back

Parameter

Beispiel

emplace_front

Parameter

Beispiel

empty

Rückgabewert

Beispiel

end

Rückgabewert

Hinweise

`deque`-Klasse

`allocator_type`

`assign`

`at`

`back`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`deque`

`difference_type`

`emplace`

`emplace_back`

`emplace_front`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`pop_front`

`push_back`

`push_front`

`rbegin`

`reference`

`rend`

`resize`

`reverse_iterator`

`shrink_to_fit`

`size`