deque (STL/CLR)

Artikel
07/19/2022
37 Minuten Lesedauer

Die Vorlagenklasse beschreibt ein Objekt, das eine unterschiedliche Sequenz von Elementen steuert, die zufälligen Zugriff haben. Sie verwenden den Container deque , um eine Abfolge von Elementen zu verwalten, die wie ein zusammenhängender Speicherblock aussieht, der jedoch an beiden Enden wachsen oder verkleinern kann, ohne dass verbleibende Elemente kopiert werden müssen. So kann es effizient eine double-ended queue. (Daher der Name.)

In der nachstehenden Beschreibung ist es gleichValue, es sei denn, GValue letzteres ist ein Bezugstyp, in diesem Fall ist Value^es .

Syntax

template<typename Value>
    ref class deque
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IDeque<GValue>
    { ..... };

Parameter

GValue
Der generische Typ eines Elements in der kontrollierten Sequenz.

Wert
Der Typ eines Elements in der kontrollierten Sequenz.

Anforderungen

Header:< cliext/deque>

Namespace: cliext

Deklarationen

Typendefinition	Beschreibung
deque::const_iterator (STL/CLR)	Der Typ eines konstanten Iterators für die gesteuerte Sequenz.
deque::const_reference (STL/CLR)	Der Typ eines konstanten Verweises auf ein Element.
deque::const_reverse_iterator (STL/CLR)	Der Typ eines konstanten umgekehrten Iterators für die gesteuerte Sequenz.
deque::difference_type (STL/CLR)	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
deque::generic_container (STL/CLR)	Der Typ der generischen Schnittstelle für den Container.
deque::generic_iterator (STL/CLR)	Der Typ eines Iterators für die generische Schnittstelle für den Container.
deque::generic_reverse_iterator (STL/CLR)	Der Typ eines Reverse-Iterators für die generische Schnittstelle für den Container.
deque::generic_value (STL/CLR)	Der Typ eines Elements für die generische Schnittstelle für den Container.
deque::iterator (STL/CLR)	Der Typ eines Iterators für die gesteuerte Sequenz.
deque::reference (STL/CLR)	Der Typ eines Verweises auf ein Element.
deque::reverse_iterator (STL/CLR)	Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.
deque::size_type (STL/CLR)	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
deque::value_type (STL/CLR)	Der Typ eines Elements.

Memberfunktion	BESCHREIBUNG
deque::assign (STL/CLR)	Ersetzt alle Elemente.
deque::at (STL/CLR)	Greift auf ein Element an einer angegebenen Position zu.
deque::back (STL/CLR)	Greift auf das letzte Element zu.
deque::begin (STL/CLR)	Legt den Anfang der kontrollierten Sequenz fest.
deque::clear (STL/CLR)	Entfernt alle Elemente.
deque::deque (STL/CLR)	Erstellt ein container-Objekt.
deque::empty (STL/CLR)	Testet, ob keine Elemente vorhanden sind.
deque::end (STL/CLR)	Legt das Ende der kontrollierten Sequenz fest.
deque::erase (STL/CLR)	Entfernt Elemente an den angegebenen Positionen.
deque::front (STL/CLR)	Greift auf das erste Element zu.
deque::insert (STL/CLR)	Fügt Elemente an einer angegebenen Position hinzu.
deque::pop_back (STL/CLR)	Entfernt das letzte Element.
deque::pop_front (STL/CLR)	Entfernt das erste Element.
deque::push_back (STL/CLR)	Fügt ein neues letztes Element hinzu.
deque::push_front (STL/CLR)	Fügt ein neues erstes Element hinzu.
deque::rbegin (STL/CLR)	Legt den Anfang der umgekehrten kontrollierten Sequenz fest.
deque::rend (STL/CLR)	Legt das Ende der umgekehrten kontrollierten Sequenz fest.
deque::resize (STL/CLR)	Ändert die Anzahl der Elemente.
deque::size (STL/CLR)	Ermittelt die Anzahl von Elementen.
deque::swap (STL/CLR)	Vertauscht den Inhalt von zwei Containern.
deque::to_array (STL/CLR)	Kopiert die kontrollierte Sequenz in ein neues Array.

Eigenschaft	BESCHREIBUNG
deque::back_item (STL/CLR)	Greift auf das letzte Element zu.
deque::front_item (STL/CLR)	Greift auf das erste Element zu.

Operator	BESCHREIBUNG
deque::operator!= (STL/CLR)	Bestimmt, ob zwei `deque`-Objekte ungleich sind.
deque::operator(STL/CLR)	Greift auf ein Element an einer angegebenen Position zu.
Operator< (deque) (STL/CLR)	Bestimmt, ob ein Objekt kleiner als ein `deque` anderes `deque` Objekt ist.
operator<= (deque) (STL/CLR)	Bestimmt, ob ein `deque` Objekt kleiner oder gleich einem anderen `deque` Objekt ist.
operator= (deque) (STL/CLR)	Ersetzt die kontrollierte Sequenz.
operator== (deque) (STL/CLR)	Bestimmt, ob ein Objekt gleich einem `deque` anderen `deque` Objekt ist.
Operator> (deque) (STL/CLR)	Bestimmt, ob ein Objekt größer als ein `deque` anderes `deque` Objekt ist.
operator>= (deque) (STL/CLR)	Bestimmt, ob ein `deque` Objekt größer oder gleich einem anderen `deque` Objekt ist.

Schnittstellen

Schnittstelle	BESCHREIBUNG
ICloneable	Duplizieren eines Objekts.
IEnumerable	Sequenzieren durch Elemente.
ICollection	Verwalten der Gruppe von Elementen.
IEnumerable<T>	Sequenz über eingegebene Elemente.
ICollection<T>	Verwalten der Gruppe der typierten Elemente.
IList<T>	Verwalten der sortierten Gruppe von typierten Elementen.
IDequeValue<>	Behalten Sie den generischen Container bei.

Hinweise

Das Objekt weist den Speicher für die Sequenz zu, die er durch ein gespeichertes Array von Handlen steuert, die Blöcke von Value Elementen festlegen. Das Array wächst nach Bedarf. Das Wachstum tritt so auf, dass die Kosten entweder vor dem Ausstehen oder Anfügen eines neuen Elements konstant sind, und keine verbleibenden Elemente werden gestört. Sie können auch ein Element zu einem einzelnen Ende in konstanter Zeit entfernen und ohne die verbleibenden Elemente zu stören. Daher ist eine Deque ein guter Kandidat für den zugrunde liegenden Container für Vorlagenklassenwarteschlange (STL/CLR) oder Vorlagenklassenstapel (STL/CLR).

Ein deque Objekt unterstützt Zufallszugriffs-Iteratoren, was bedeutet, dass Sie direkt auf ein Element verweisen können, das seine numerische Position zugewiesen hat, gezählt von Null für das erste (Front)-Element, um deque:::size (STL/CLR) für das letzte (Back)() - 1-Element zu verwenden. Es bedeutet auch, dass eine Deque ein guter Kandidat für den zugrunde liegenden Container für die Vorlagenklasse priority_queue (STL/CLR) ist.

Ein deque iterator speichert einen Handle mit dem zugeordneten Deque-Objekt zusammen mit der Verzerrung des elements, das er angibt. Sie können Iteratoren nur mit ihren zugeordneten Containerobjekten verwenden. Die Verzerrung eines deque-Elements entspricht nicht unbedingt der Position. Das erste eingefügte Element hat Bias Null, das nächste angefügte Element hat 1, aber das nächste voreingestellte Element hat Bias -1.

Das Einfügen oder Löschen von Elementen am Ende ändert den Wert eines Elements, das bei gültigen Verzerrungen gespeichert ist, nicht . Das Einfügen oder Löschen eines Innenelements kann jedoch den bei einer bestimmten Verzerrung gespeicherten Elementwert ändern, sodass der von einem Iterator angegebene Wert auch geändert werden kann . (Der Container muss Möglicherweise Elemente nach oben oder unten kopieren, um ein Loch zu erstellen, bevor ein Einfügen oder ein Loch nach einem Löschvorgang gefüllt werden soll.) Dennoch bleibt ein deque iterator gültig, solange seine Verzerrung ein gültiges Element angibt. Darüber hinaus bleibt ein gültiger Iterator nicht mehr möglich - Sie können es verwenden, um auf den von ihm festgelegten Elementwert zuzugreifen oder zu ändern - solange seine Verzerrung nicht der Verzerrung für den von ihm zurückgegebenen end()Iterator entspricht.

Das Löschen oder Entfernen eines Elements ruft den Destruktor für seinen gespeicherten Wert auf. Durch das Zerstören des Containers werden alle Elemente gelöscht. Daher stellt ein Container, dessen Elementtyp eine Ref-Klasse ist, sicher, dass keine Elemente den Container ausleben. Beachten Sie jedoch, dass ein Container von Handlen seine Elemente nicht zerstört.

Member

deque::assign (STL/CLR)

Ersetzt alle Elemente.

Syntax

void assign(size_type count, value_type val);
template<typename InIt>
    void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);

Parameter

count
Die Anzahl einzufügender Elemente.

first
Anfang des zu einfügenden Bereichs.

last
Ende des zu einfügenden Bereichs.

right
Aufzählung, die eingefügt werden soll.

Val
Wert des elements, das eingefügt werden soll.

Hinweise

Die erste Memberfunktion ersetzt die kontrollierte Sequenz durch eine Wiederholung der Anzahl von Elementen des Wertwerts. Sie verwenden es, um den Container mit Elementen zu füllen, die denselben Wert haben.

Wenn InIt es sich um einen ganzzahligen Typ handelt, verhält sich die zweite Memberfunktion wie assign((size_type)first, (value_type)last). Andernfalls ersetzt er die kontrollierte Sequenz durch die Sequenz [first, last). Sie verwenden es, um die kontrollierte Sequenz zu einer anderen Sequenz zu machen.

Die dritte Memberfunktion ersetzt die kontrollierte Sequenz durch die durch das Enumeratorrecht festgelegte Sequenz. Sie verwenden es, um die kontrollierte Sequenz eine Kopie einer Sequenz zu erstellen, die von einer Aufzählung beschrieben wird.

Beispiel

// cliext_deque_assign.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // assign a repetition of values
    cliext::deque<wchar_t> c2;
    c2.assign(6, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an iterator range
    c2.assign(c1.begin(), c1.end() - 1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an enumeration
    c2.assign(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

x x x x x x
a b
a b c

deque::at (STL/CLR)

Greift auf ein Element an einer angegebenen Position zu.

Syntax

reference at(size_type pos);

Parameter

pos
Position des Elements, auf das zugegriffen wird

Hinweise

Die Memberfunktion gibt einen Verweis auf das Element der kontrollierten Sequenz an position pos zurück. Sie verwenden es, um ein Element zu lesen oder zu schreiben, dessen Position Sie kennen.

Beispiel

// cliext_deque_at.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using at
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

    // change an entry and redisplay
    c1.at(1) = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::back (STL/CLR)

Greift auf das letzte Element zu.

Syntax

reference back();

Hinweise

Die Memberfunktion gibt einen Verweis auf das letzte Element der kontrollierten Sequenz zurück, die nicht leer sein muss. Sie verwenden es, um auf das letzte Element zuzugreifen, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// cliext_deque_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("back() = {0}", c1.back());

    // alter last item and reinspect
    c1.back() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back() = c
a b x

deque::back_item (STL/CLR)

Greift auf das letzte Element zu.

Syntax

property value_type back_item;

Hinweise

Die Eigenschaft greift auf das letzte Element der kontrollierten Sequenz zu, die nicht leer sein muss. Sie verwenden es, um das letzte Element zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// cliext_deque_back_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("back_item = {0}", c1.back_item);

    // alter last item and reinspect
    c1.back_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back_item = c
a b x

deque::begin (STL/CLR)

Legt den Anfang der kontrollierten Sequenz fest.

Syntax

iterator begin();

Hinweise

Die Memberfunktion gibt einen Zufallszugriffs-Iterator zurück, der das erste Element der kontrollierten Sequenz oder direkt über das Ende einer leeren Sequenz bestimmt. Sie können damit einen Iterator abrufen, der den current Anfang der kontrollierten Sequenz bestimmt; der Zustand kann sich jedoch ändern, sobald sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_deque_begin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    cliext::deque<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*begin() = a
*++begin() = b
x y c

deque::clear (STL/CLR)

Entfernt alle Elemente.

Syntax

void clear();

Hinweise

Die Memberfunktion ruft effektiv deque::erase (STL/CLR)(deque::begin (STL/CLR)deque::end (STL/CLR)())(), auf. Sie verwenden es, um sicherzustellen, dass die kontrollierte Sequenz leer ist.

Beispiel

// cliext_deque_clear.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

deque::const_iterator (STL/CLR)

Der Typ eines konstanten Iterators für die gesteuerte Sequenz.

Syntax

typedef T2 const_iterator;

Hinweise

Der Typ beschreibt ein Objekt des nicht angegebenen Typs T2 , das als konstanter Zufallszugriffs-Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_deque_const_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::deque<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::const_reference (STL/CLR)

Der Typ eines konstanten Verweises auf ein Element.

Syntax

typedef value_type% const_reference;

Hinweise

Der Typ beschreibt einen Konstantenverweis auf ein Element.

Beispiel

// cliext_deque_const_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::deque<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::deque<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::const_reverse_iterator (STL/CLR)

Der Typ einer Konstantenumdrehungs-Iterator für die kontrollierte Sequenz..

Syntax

typedef T4 const_reverse_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T4 , das als konstanter Umgekehrter Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_deque_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::deque<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::deque<wchar_t>::const_reverse_iterator crend = c1.rend();
    for (; crit != crend; ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

deque::deque (STL/CLR)

Erstellt ein container-Objekt.

Syntax

deque();
deque(deque<Value>% right);
deque(deque<Value>^ right);
explicit deque(size_type count);
deque(size_type count, value_type val);
template<typename InIt>
    deque(InIt first, InIt last);
deque(System::Collections::Generic::IEnumerable<Value>^ right);

Parameter

count
Die Anzahl einzufügender Elemente.

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

right
Einzufügendes Objekt bzw. einzufügender Bereich.

Val
Wert des einzufügenden Elements.

Hinweise

Der Konstruktor:

deque();

initialisiert die kontrollierte Sequenz ohne Elemente. Sie verwenden es, um eine leere anfängliche kontrollierte Sequenz anzugeben.

Der Konstruktor:

deque(deque<Value>% right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right.begin(), right.end()). Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der Sequenz ist, die vom deque-Objekt rechts gesteuert wird. Weitere Informationen zu den Iteratoren finden Sie unter deque::begin (STL/CLR) und deque::end (STL/CLR).

Der Konstruktor:

deque(deque<Value>^ right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right->begin(), right->end()). Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der Sequenz ist, die vom deque-Objekt gesteuert wird, dessen Handle rechts ist.

Der Konstruktor:

explicit deque(size_type count);

initialisiert die kontrollierte Sequenz mit Zählungselementen mit jedem Wert value_type(). Sie verwenden ihn, um den Container mit Elementen zu füllen, die den Standardwert aufweisen.

Der Konstruktor:

deque(size_type count, value_type val);

initialisiert die kontrollierte Sequenz mit Zählungselementen jeweils mit Wert val. Sie verwenden ihn, um den Container mit Elementen zu füllen, die denselben Wert aufweisen.

Der Konstruktor:

template<typename InIt>

deque(InIt first, InIt last);

initialisiert die kontrollierte Sequenz mit der Sequenz [first, last). Sie verwenden es, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen.

Der Konstruktor:

deque(System::Collections::Generic::IEnumerable<Value>^ right);

initialisiert die kontrollierte Sequenz mit der sequenz, die vom Enumerator rechts festgelegt wird. Sie verwenden es, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen, die von einer Aufzählung beschrieben wird.

Beispiel

// cliext_deque_construct.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container
    cliext::deque<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    // construct with a repetition of default values
    cliext::deque<wchar_t> c2(3);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // construct with a repetition of values
    cliext::deque<wchar_t> c3(6, L'x');
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range
    cliext::deque<wchar_t>::iterator it = c3.end();
    cliext::deque<wchar_t> c4(c3.begin(), --it);
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration
    cliext::deque<wchar_t> c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    cliext::deque<wchar_t> c7(c3);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying a container handle
    cliext::deque<wchar_t> c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x

deque::difference_type (STL/CLR)

Die Typen eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int difference_type;

Hinweise

Der Typ beschreibt eine signierte Elementanzahl.

Beispiel

// cliext_deque_difference_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    cliext::deque<wchar_t>::difference_type diff = 0;
    for (cliext::deque<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it) ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (cliext::deque<wchar_t>::iterator it = c1.end();
        it != c1.begin(); --it) --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3
begin()-end() = -3

deque::empty (STL/CLR)

Testet, ob keine Elemente vorhanden sind.

Syntax

bool empty();

Hinweise

Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück. Es entspricht deque::size (STL/CLR)() == 0. Sie verwenden es, um zu testen, ob die Deque leer ist.

Beispiel

// cliext_deque_empty.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

deque::end (STL/CLR)

Legt das Ende der kontrollierten Sequenz fest.

Syntax

iterator end();

Hinweise

Die Memberfunktion gibt einen Zufallszugriffs-Iterator zurück, der direkt über das Ende der kontrollierten Sequenz verweist. Sie können damit einen Iterator abrufen, der das current Ende der kontrollierten Sequenz bestimmt; der Zustand kann sich jedoch ändern, sobald sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_deque_end.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last two items
    cliext::deque<wchar_t>::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --end() = b
*--end() = c
a x y

deque::erase (STL/CLR)

Entfernt Elemente an den angegebenen Positionen.

Syntax

iterator erase(iterator where);
iterator erase(iterator first, iterator last);

Parameter

first
Anfang des zu löschenden Bereichs.

last
Ende des zu löschenden Bereichs.

where
Element, das gelöscht werden soll.

Hinweise

Mit der ersten Memberfunktion wird das Element der kontrollierten Sequenz entfernt, auf das an der Stelle verwiesen wird. Sie verwenden es, um ein einzelnes Element zu entfernen.

Die zweite Memberfunktion entfernt die Elemente der gesteuerten Sequenz im Bereich [first, last). Sie verwenden es, um null oder mehr zusammenhängende Elemente zu entfernen.

Beide Memberfunktionen geben einen Iterator zurück, der das erste Element bestimmt, das über alle entfernten Elemente hinausgeht, oder deque::end (STL/CLR),() wenn kein solches Element vorhanden ist.

Beim Löschen von Elementen ist die Anzahl der Elementkopien in der Anzahl der Elemente zwischen dem Ende der Löschung und dem näheren Ende der Sequenz linear. (Beim Löschen eines oder mehrerer Elemente am Ende der Sequenz treten keine Elementkopien auf.)

Beispiel

// cliext_deque_erase.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.push_back(L'd');
    c1.push_back(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    cliext::deque<wchar_t>::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

deque::front (STL/CLR)

Greift auf das erste Element zu.

Syntax

reference front();

Hinweise

Die Memberfunktion gibt einen Verweis auf das erste Element der kontrollierten Sequenz zurück, die nicht leer sein muss. Sie verwenden es, um das erste Element zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// cliext_deque_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first item
    System::Console::WriteLine("front() = {0}", c1.front());

    // alter first item and reinspect
    c1.front() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front() = a
x b c

deque::front_item (STL/CLR)

Greift auf das erste Element zu.

Syntax

property value_type front_item;

Hinweise

Die Eigenschaft greift auf das erste Element der kontrollierten Sequenz zu, die nicht leer sein muss. Sie verwenden es, um das erste Element zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

// cliext_deque_front_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first item
    System::Console::WriteLine("front_item = {0}", c1.front_item);

    // alter first item and reinspect
    c1.front_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front_item = a
x b c

deque::generic_container (STL/CLR)

Der Typ der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::
    IDeque<generic_value>
    generic_container;

Hinweise

Der Typ beschreibt die generische Schnittstelle für diese Vorlagencontainerklasse.

Beispiel

// cliext_deque_generic_container.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(gc1->end(), L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.push_back(L'e');

    System::Collections::IEnumerator^ enum1 =
        gc1->GetEnumerator();
    while (enum1->MoveNext())
        System::Console::Write("{0} ", enum1->Current);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

deque::generic_iterator (STL/CLR)

Der Typ eines Iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerRandomAccessIterator<generic_value> generic_iterator;

Hinweise

Der Typ beschreibt einen generischen Iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

// cliext_deque_generic_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

deque::generic_reverse_iterator (STL/CLR)

Der Typ eines Reverse-Iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value> generic_reverse_iterator;

Hinweise

Der Typ beschreibt einen generischen Reverse-Iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

// cliext_deque_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::deque<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a c c

deque::generic_value (STL/CLR)

Der Typ eines Elements für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef GValue generic_value;

Hinweise

Der Typ beschreibt ein Objekt des Typs GValue , das den gespeicherten Elementwert beschreibt, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet wird.

Beispiel

// cliext_deque_generic_value.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::deque<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

deque::insert (STL/CLR)

Fügt Elemente an einer angegebenen Position hinzu.

Syntax

iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
    void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
    System::Collections::Generic::IEnumerable<Value>^ right);

Parameter

count
Die Anzahl einzufügender Elemente.

first
Anfang des zu einfügenden Bereichs.

last
Ende des zu einfügenden Bereichs.

right
Aufzählung, die eingefügt werden soll.

Val
Wert des elements, das eingefügt werden soll.

where
Wo im Container vor dem Einfügen eingefügt werden soll.

Hinweise

Jede der Memberfunktionen fügt ein, bevor das Element darauf verweist, wo in der kontrollierten Sequenz eine Sequenz angegeben wird, die von den verbleibenden Operanden angegeben wird.

Die erste Memberfunktion fügt ein Element mit Wertwert val ein und gibt einen Iterator zurück, der das neu eingefügte Element angibt. Sie verwenden es, um ein einzelnes Element vor einem ort einzufügen, der von einem Iterator festgelegt ist.

Die zweite Memberfunktion fügt eine Wiederholung der Anzahl von Wertelementen des Wertwerts ein. Sie verwenden es, um null oder mehr zusammenhängende Elemente einzufügen, die alle Kopien desselben Werts sind.

Wenn InIt ein Ganzzahltyp ist, verhält sich die dritte Memberfunktion genau wie insert(where, (size_type)first, (value_type)last). Andernfalls fügt er die Sequenz [first, last). Sie verwenden es, um null oder mehr zusammenhängende Elemente einzufügen, die aus einer anderen Sequenz kopiert wurden.

Die vierte Memberfunktion fügt die Sequenz ein, die von der rechten Seite festgelegt ist. Sie verwenden es, um eine Sequenz einzufügen, die von einem Aufzählerator beschrieben wird.

Beim Einfügen eines einzelnen Elements ist die Anzahl der Elementkopien linear in der Anzahl der Elemente zwischen der Einfügemarke und dem näheren Ende der Sequenz. (Beim Einfügen eines oder mehrerer Elemente am Ende der Sequenz treten keine Elementkopien auf.) Wenn InIt es sich um einen Eingabe-Iterator handelt, führt die dritte Memberfunktion effektiv eine einzelne Einfügefunktion für jedes Element in der Sequenz aus. Andernfalls N ist die Anzahl der Elementkopien linear N und die Anzahl der Elemente zwischen der Einfügemarke und dem näheren Ende der Sequenz.

Beispiel

// cliext_deque_insert.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value using iterator
    cliext::deque<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
        *c1.insert(++it, L'x'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a repetition of values
    cliext::deque<wchar_t> c2;
    c2.insert(c2.begin(), 2, L'y');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    it = c1.end();
    c2.insert(c2.end(), c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    c2.insert(c2.begin(),   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b

deque::iterator (STL/CLR)

Der Typ eines Iterators für die gesteuerte Sequenz.

Syntax

typedef T1 iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T1 , das als Zufallszugriffs-Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_deque_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::deque<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();

    // alter first element and redisplay
    it = c1.begin();
    *it = L'x';
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c
x b c

deque::operator!= (STL/CLR)

Nicht gleich vergleicht.

Syntax

template<typename Value>
    bool operator!=(deque<Value>% left,
        deque<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt !(left == right)zurück. Sie verwenden es, um zu testen, ob links nicht gleich nach rechts angeordnet ist, wenn die beiden Deques das Element nach Element verglichen werden.

Beispiel

// cliext_deque_operator_ne.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

deque::operator(STL/CLR)

Greift auf ein Element an einer angegebenen Position zu.

Syntax

reference operator[](size_type pos);

Parameter

pos
Position des Elements, auf das zugegriffen wird

Hinweise

Der Memberoperator gibt einen Verweis auf das Element an position pos zurück. Sie verwenden es, um auf ein Element zuzugreifen, dessen Position Sie kennen.

Beispiel

// cliext_deque_operator_sub.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using subscripting
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();

    // change an entry and redisplay
    c1[1] = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::pop_back (STL/CLR)

Entfernt das letzte Element.

Syntax

void pop_back();

Hinweise

Die Memberfunktion entfernt das letzte Element der kontrollierten Sequenz, die nicht leer sein muss. Sie verwenden es, um die Deque um ein Element auf der Rückseite zu kürzen.

Beispiel

// cliext_deque_pop_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // pop an element and redisplay
    c1.pop_back();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b

deque::pop_front (STL/CLR)

Entfernt das erste Element.

Syntax

void pop_front();

Hinweise

Die Memberfunktion entfernt das erste Element der kontrollierten Sequenz, das nicht leer sein muss. Sie verwenden es, um die Deque um ein Element an der Vorderseite zu kürzen.

Beispiel

// cliext_deque_pop_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // pop an element and redisplay
    c1.pop_front();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
b c

deque::push_back (STL/CLR)

Fügt ein neues letztes Element hinzu.

Syntax

void push_back(value_type val);

Hinweise

Die Memberfunktion fügt ein Element mit Dem Wert val am Ende der kontrollierten Sequenz ein. Sie verwenden es, um ein anderes Element an die Deque anzufügen.

Beispiel

// cliext_deque_push_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::push_front (STL/CLR)

Fügt ein neues erstes Element hinzu.

Syntax

void push_front(value_type val);

Hinweise

Die Memberfunktion fügt ein Element mit Dem Wert val am Anfang der kontrollierten Sequenz ein. Sie verwenden es, um ein anderes Element auf die Deque vorzuleiten.

Beispiel

// cliext_deque_push_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_front(L'a');
    c1.push_front(L'b');
    c1.push_front(L'c');

    // display contents " c b a"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c b a

deque::rbegin (STL/CLR)

Legt den Anfang der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rbegin();

Hinweise

Die Memberfunktion gibt einen umgekehrten Iterator zurück, der das letzte Element der kontrollierten Sequenz oder direkt über den Anfang einer leeren Sequenz bestimmt. Demzufolge wird der beginning der umgekehrten Sequenz bestimmt. Sie können damit einen Iterator abrufen, der den current Anfang der kontrollierten Sequenz in umgekehrter Reihenfolge bestimmt; der Zustand kann sich jedoch ändern, sobald sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_deque_rbegin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b
a y x

deque::reference (STL/CLR)

Der Typ eines Verweises auf ein Element.

Syntax

typedef value_type% reference;

Hinweise

Der Typ beschreibt einen Verweis auf ein Element.

Beispiel

// cliext_deque_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::deque<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::deque<wchar_t>::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();

    // modify contents " a b c"
    for (it = c1.begin(); it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::deque<wchar_t>::reference ref = *it;

        ref += (wchar_t)(L'A' - L'a');
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c
A B C

deque::rend (STL/CLR)

Legt das Ende der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rend();

Hinweise

Die Memberfunktion gibt einen umgekehrten Iterator zurück, der direkt über den Anfang der kontrollierten Sequenz hinaus zeigt. Demzufolge wird der end der umgekehrten Sequenz bestimmt. Sie können damit einen Iterator abrufen, der das current Ende der kontrollierten Sequenz in umgekehrter Reihenfolge bestimmt; der Zustand kann sich jedoch ändern, sobald sich die Länge der kontrollierten Sequenz ändert.

Beispiel

// cliext_deque_rend.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a
y x c

deque::resize (STL/CLR)

Ändert die Anzahl der Elemente.

Syntax

void resize(size_type new_size);
void resize(size_type new_size, value_type val);

Parameter

new_size
Neue Größe der kontrollierten Sequenz.

Val
Wert des Abstandselements.

Hinweise

Die Memberfunktionen stellen sicher, dass deque::size (STL/CLR)() daher new_size zurückgibt. Wenn die kontrollierte Sequenz länger sein muss, fügt die erste Elementfunktion Elemente mit Wert value_type()an, während die zweite Memberfunktion Elemente mit Wertwert anfüge. Um die kontrollierte Sequenz kürzer zu machen, löschen beide Memberfunktionen effektiv das letzte Element deque::size (STL/CLR)() -new_size Zeiten. Sie verwenden es, um sicherzustellen, dass die kontrollierte Sequenz größe new_size hat, indem Sie die aktuelle kontrollierte Sequenz kürzen oder auffüllen.

Beispiel

// cliext_deque_resize.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container and pad with default values
    cliext::deque<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());
    c1.resize(4);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // resize to empty
    c1.resize(0);
    System::Console::WriteLine("size() = {0}", c1.size());

    // resize and pad
    c1.resize(5, L'x');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
0 0 0 0
size() = 0
x x x x x

deque::reverse_iterator (STL/CLR)

Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.

Syntax

typedef T3 reverse_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T3 , das als umgekehrter Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

// cliext_deque_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::deque<wchar_t>::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();

    // alter first element and redisplay
    rit = c1.rbegin();
    *rit = L'x';
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a
x b a

deque::size (STL/CLR)

Ermittelt die Anzahl von Elementen.

Syntax

size_type size();

Hinweise

Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück. Sie verwenden es, um die Anzahl der elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befindet. Wenn Sie sich darum kümmern, ob die Sequenz nicht zerogröße hat, lesen Sie deque::empty (STL/CLR)().

Beispiel

// cliext_deque_size.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

deque::size_type (STL/CLR)

Der Typ eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int size_type;

Hinweise

Der Typ beschreibt eine nicht negative Elementanzahl.

Beispiel

// cliext_deque_size_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    cliext::deque<wchar_t>::size_type diff = c1.end() - c1.begin();
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

deque::swap (STL/CLR)

Vertauscht den Inhalt von zwei Containern.

Syntax

void swap(deque<Value>% right);

Parameter

right
Container für den Tausch von Inhalten.

Hinweise

Die Memberfunktion wechselt die kontrollierten Sequenzen zwischen *this und rechts. Dies erfolgt in konstanter Zeit und löst keine Ausnahmen aus. Sie verwenden es als schnelle Möglichkeit, den Inhalt von zwei Containern auszutauschen.

Beispiel

// cliext_deque_swap.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    cliext::deque<wchar_t> c2(5, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
x x x x x
x x x x x
a b c

deque::to_array (STL/CLR)

Kopiert die kontrollierte Sequenz in ein neues Array.

Syntax

cli::array<Value>^ to_array();

Hinweise

Die Memberfunktion gibt ein Array zurück, das die kontrollierte Sequenz enthält. Sie verwenden es, um eine Kopie der kontrollierten Sequenz in Arrayform abzurufen.

Beispiel

// cliext_deque_to_array.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.push_back(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

deque::value_type (STL/CLR)

Der Typ eines Elements.

Syntax

typedef Value value_type;

Hinweise

Der Typ ist ein Synonym für den Vorlagenparameter Value.

Beispiel

// cliext_deque_value_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using value_type
    for (cliext::deque<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        {   // store element in value_type object
        cliext::deque<wchar_t>::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`operator<` (deque) (STL/CLR)

Deque kleiner als vergleich.

Syntax

template<typename Value>
    bool operator<(deque<Value>% left,
        deque<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt true zurück, wenn für die niedrigste Position i , für !(right[i] < left[i]) die sie auch wahr left[i] < right[i]ist. Andernfalls gibt left->size() < right->size() sie sie zurück, um zu testen, ob links vor rechts angeordnet wird, wenn die beiden Deques elemente nach Element verglichen werden.

Beispiel

// cliext_deque_operator_lt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

`operator<=` (deque) (STL/CLR)

Deque kleiner als oder gleich vergleicht.

Syntax

template<typename Value>
    bool operator<=(deque<Value>% left,
        deque<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt !(right < left)zurück. Sie verwenden es, um zu testen, ob links nach rechts nicht angeordnet wird, wenn die beiden Deques element nach Element verglichen werden.

Beispiel

// cliext_deque_operator_le.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

operator= (deque) (STL/CLR)

Ersetzt die kontrollierte Sequenz.

Syntax

deque<Value>% operator=(deque<Value>% right);

Parameter

right
Der zu kopierende Container.

Hinweise

Der Memberoperator kopiert direkt im Objekt, und gibt dann zurück *this. Sie verwenden es, um die kontrollierte Sequenz durch eine Kopie der kontrollierten Sequenz rechts zu ersetzen.

Beispiel

// cliext_deque_operator_as.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2 = c1;
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

operator== (deque) (STL/CLR)

Gleich vergleicht.

Syntax

template<typename Value>
    bool operator==(deque<Value>% left,
        deque<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt nur wahr zurück, wenn die von links und rechts gesteuerten Sequenzen die gleiche Länge aufweisen und für jede Position ileft[i] ==right[i]. Sie verwenden es, um zu testen, ob links nach rechts angeordnet wird, wenn die beiden Deques elemente nach Element verglichen werden.

Beispiel

// cliext_deque_operator_eq.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

`operator>` (deque) (STL/CLR)

Que größer als vergleich.

Syntax

template<typename Value>
    bool operator>(deque<Value>% left,
        deque<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt right<leftzurück. Sie verwenden es, um zu testen, ob links nach rechts angeordnet wird, wenn die beiden Deques das Element nach Element verglichen werden.

Beispiel

// cliext_deque_operator_gt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

`operator>=` (deque) (STL/CLR)

Deque größer als oder gleich vergleicht.

Syntax

template<typename Value>
    bool operator>=(deque<Value>% left,
        deque<Value>% right);

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt !(left<right)zurück. Sie verwenden es, um zu testen, ob links nicht vor rechts angeordnet ist, wenn die beiden Deques das Element nach Element verglichen werden.

Beispiel

// cliext_deque_operator_ge.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::deque<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False