deque (STL/CLR)
Die Vorlagenklasse beschreibt ein Objekt, das eine unterschiedliche Abfolge von Elementen steuert, die zufälligen Zugriff haben. Sie verwenden den Containerdeque, um eine Abfolge von Elementen zu verwalten, die wie ein zusammenhängender Speicherblock aussieht, der jedoch an beiden Enden vergrößert oder verkleinern kann, ohne dass elemente erneut kopiert werden müssen Standard. So kann es effizient eine double-ended queue. (Daher der Name.)
In der nachstehenden Beschreibung ist identisch mit Value dem, 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 gesteuerten 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 nicht gleich 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 Objekt kleiner oder gleich einem deque anderen deque Objekt ist. |
| operator= (deque) (STL/CLR) | Ersetzt die kontrollierte Sequenz. |
| operator== (deque) (STL/CLR) | Bestimmt, ob ein Objekt mit einem deque anderen deque Objekt identisch 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 Objekt größer oder gleich einem deque anderen deque Objekt ist. |
Schnittstellen
| Schnittstelle | Beschreibung |
|---|---|
| ICloneable | Duplizieren Eines Objekts. |
| IEnumerable | Sequenzieren durch Elemente. |
| ICollection | Verwalten sie eine Gruppe von Elementen. |
| IEnumerable<T> | Sequenz durch eingegebene Elemente. |
| ICollection<T> | Verwalten der Gruppe von typierten Elementen. |
| IList<T> | Verwalten Sie sortierte Gruppe von typierten Elementen. |
| IDeque-Wert<> | Verwalten Sie generischen Container. |
Hinweise
Das Objekt reserviert und gibt Speicherplatz für die Sequenz frei, die durch ein gespeichertes Handlearray gesteuert wird, das Blöcke von Value Elementen angibt. Das Array wächst bei Bedarf. Das Wachstum erfolgt so, dass die Kosten für das Vor- oder Anfügen eines neuen Elements konstant sind und keine Elemente erneut Standard gestört werden. Sie können ein Element auch an beiden Enden in konstanter Zeit entfernen und ohne störende Elemente Standard. 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 Iteratoren mit wahlfreiem Zugriff, was bedeutet, dass Sie direkt auf ein Element verweisen können, das seine numerische Position angibt, von Null für das erste (Front)-Element auf deque::size (STL/CLR)() - 1 für das letzte (zurück)-Element. 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 ein Handle für das zugeordnete deque-Objekt zusammen mit der Verzerrung des von ihm bezeichneten Elements. Sie können Iteratoren nur mit den zugehörigen Containerobjekten verwenden. Die Verzerrung eines deque-Elements ist nicht unbedingt identisch mit seiner Position. Das erste eingefügte Element hat Bias Null, das nächste angefügte Element hat Bias 1, aber das nächste vorangestellte Element hat Bias -1.
Das Einfügen oder Löschen von Elementen am Ende ändert nicht den Wert eines Elements, das bei einer gültigen Abweichung gespeichert ist. Das Einfügen oder Löschen eines Innenelements kann jedoch den bei einer bestimmten Abweichung gespeicherten Elementwert ändern, sodass sich auch der von einem Iterator festgelegte Wert ändern kann. (Möglicherweise muss der Container Elemente nach oben oder unten kopieren, um ein Loch vor dem Einfügen zu erstellen oder ein Loch nach einem Radierer zu füllen.) Dennoch ist eine deque iterator re Standard gültig, solange ihre Verzerrung ein gültiges Element angibt. Darüber hinaus kann ein gültiger Iterator re Standard s dereferencable -- Sie können ihn verwenden, um auf den von ihm festgelegten Elementwert zuzugreifen oder zu ändern - solange seine Verzerrung nicht der Verzerrung für den iterator entspricht, der von end().
Beim Löschen oder Entfernen eines Elements wird der Destruktor für den gespeicherten Wert aufgerufen. 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 überleben. Beachten Sie jedoch, dass ein Container mit Ziehpunkten 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 einzufügenden Bereichs.
last
Ende des einzufügenden Bereichs.
right
Einzufügende Aufzählung.
val
Wert des einzufügenden Elements.
Hinweise
Die erste Memberfunktion ersetzt die kontrollierte Sequenz durch eine Wiederholung von Anzahlelementen von Wertwertwert. Sie verwenden ihn, um den Container mit Elementen zu füllen, die denselben Wert aufweisen.
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 sie die kontrollierte Sequenz durch die Sequenz [first, last). Sie verwenden sie, um die kontrollierte Sequenz zu einer anderen Sequenz zu machen.
Die dritte Memberfunktion ersetzt die gesteuerte Sequenz durch die sequenz, die durch das Enumeratorrecht festgelegt ist. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer Sequenz zu machen, die von einem Enumerator 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 gesteuerten 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 gesteuerten 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 gesteuerten 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 Iterator mit wahlfreiem Zugriff zurück, der das erste Element der kontrollierten Sequenz oder direkt über das Ende einer leeren Sequenz bestimmt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, aber sein Status kann sich ändern, wenn 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 nicht angegebener Typs T2 , das als konstanter Iterator für den zufälligen Zugriff 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 Konstantenumkehr iterator für die kontrollierte Sequenz..
Syntax
typedef T4 const_reverse_iterator;
Hinweise
Der Typ beschreibt ein Objekt nicht angegebener Typs T4 , das als konstanten Reverse 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 sie, 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 durch das 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 durch das 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 alle den Standardwert aufweisen.
Der Konstruktor:
deque(size_type count, value_type val);
initialisiert die kontrollierte Sequenz mit Zählungselementen , die jeweils einen Wertwert aufweisen. 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 sie, 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 ist. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen, die von einem Enumerator 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 Iterator mit zufälligem Zugriff zurück, der unmittelbar über das Ende der kontrollierten Sequenz verweist. Sie verwenden es, um einen Iterator zu erhalten, der das current Ende der kontrollierten Sequenz angibt, aber sein Status kann sich ändern, wenn 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
Die erste Memberfunktion entfernt das Element der kontrollierten Sequenz, auf die durch die 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 neu angibt Standard 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 linear in der Anzahl der Elemente zwischen dem Ende der Löschung und dem näheren Ende der Sequenz. (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 gesteuerten 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 vom Typ GValue , das den gespeicherten Elementwert für die Verwendung mit der generischen Schnittstelle für diese Vorlagencontainerklasse beschreibt.
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 einzufügenden Bereichs.
last
Ende des einzufügenden Bereichs.
right
Einzufügende Aufzählung.
val
Wert des einzufügenden Elements.
where
Position im Container, der zuvor eingefügt werden soll.
Hinweise
Jede der Memberfunktionen fügt vor dem Element, auf das in der gesteuerten Sequenz verwiesen wird, eine durch die re Standard ing Operanden angegebene Sequenz ein.
Die erste Memberfunktion fügt ein Element mit Wertwert ein und gibt einen Iterator zurück, der das neu eingefügte Element angibt. Sie verwenden es, um ein einzelnes Element vor einer von einem Iterator festgelegten Stelle einzufügen.
Die zweite Memberfunktion fügt eine Wiederholung von Anzahlelementen von Wertwertwert ein. Sie verwenden sie, 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 wird die Sequenz [first, last) eingefügt. Sie verwenden sie, um null oder mehr zusammenhängende Elemente einzufügen, die aus einer anderen Sequenz kopiert wurden.
Die vierte Memberfunktion fügt die von der rechten Seite festgelegte Sequenz ein. Sie verwenden sie, um eine von einem Enumerator beschriebene Sequenz einzufügen.
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ügung für jedes Element in der Sequenz durch. Andernfalls ist N beim Einfügen N von Elementen die Anzahl der Elementkopien linear 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)
Ungleicher 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 zurück !(left == right). Sie verwenden es, um zu testen, ob links nicht gleich geordnet ist wie rechts , wenn die beiden Deques elementweise 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. 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 gesteuerten Sequenz, das nicht leer sein muss. Sie verwenden es, um die Deque um ein Element im Hintergrund 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 gesteuerten 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 gesteuerten 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 gesteuerten Sequenz ein. Sie verwenden es, um ein anderes Element der Deque voranzuleiten.
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 gesteuerten Sequenz oder direkt hinter dem Anfang einer leeren Sequenz angibt. Daher wird die beginning umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn 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 unmittelbar über den Anfang der gesteuerten Sequenz verweist. Daher wird die end umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der das current Ende der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn 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 gesteuerten 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 Memberfunktion Elemente mit Wert value_type()an, während die zweite Memberfunktion Elemente mit Wertwert anfüge. Um die kontrollierte Sequenz zu verkürzen, 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 entweder 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 nur darum kümmern, ob die Sequenz keine Zerogröße aufweist, 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 gesteuerten Sequenzen zwischen *this und rechts. Dies geschieht 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 Positioni, für die !(right[i] < left[i]) sie auch wahr ist.left[i] < right[i] Andernfalls gibt left->size() < right->size() sie zurück, um zu testen, ob links vor rechts sortiert ist, wenn die beiden Deques element 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 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 zurück !(right < left). Sie verwenden es, um zu testen, ob links nach rechts nicht sortiert ist, wenn die beiden Deques elementweise 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 in das Objekt und gibt dann zurück *this. Sie verwenden sie, um die kontrollierte Sequenz durch eine Kopie der gesteuerten 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)
Deque equal comparison.
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" nur zurück, wenn die von links und rechts gesteuerten Sequenzen dieselbe Länge und für jede Position left[i] ==right[i]idie gleiche Länge aufweisen. Sie verwenden es, um zu testen, ob links mit der rechten Reihenfolge sortiert wird, wenn die beiden Deques 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)
Deque 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 zurück right<left. Sie verwenden es, um zu testen, ob links nach rechts sortiert wird, wenn die beiden Deques 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 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 zurück !(left<right). Sie verwenden es, um zu testen, ob links nicht vor rechts sortiert ist, wenn die beiden Deques elementweise 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
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für