`queue` (STL/CLR)

Artikel
10/12/2023

Die Vorlagenklasse beschreibt ein Objekt, das eine unterschiedliche Längenfolge von Elementen steuert, für die der First-in-First-Out-Zugriff verfügbar ist. Verwenden Sie den Containeradapter queue , um einen zugrunde liegenden Container als Warteschlange zu verwalten.

In der folgenden Beschreibung ist identisch mit Value dem, es sei denn, GValue letzteres ist ein Bezugstyp, in diesem Fall ist es Value^. Ebenso ist dies identisch mit Container dem, es sei denn, GContainer letzteres ist ein Bezugstyp, in diesem Fall ist dies Container^der Fall.

Syntax

template<typename Value,
    typename Container>
    ref class queue
        :   public
        System::ICloneable,
        Microsoft::VisualC::StlClr::IQueue<GValue, GContainer>
    { ..... };

Parameter

Value
Der Typ eines Elements in der kontrollierten Sequenz.

Container
Der Typ des zugrunde liegenden Containers.

Anforderungen

Header: <cliext/queue>

Namespace:cliext

Wichtig

Um die Beispiele in diesem Thema zu kompilieren, stellen Sie sicher, dass Sie die C++/CLI-Unterstützung installiert haben, wie unter Installieren von C++/CLI-Unterstützung in Visual Studio 2022 beschrieben. Erstellen Sie für den Projekttyp eine CLR-Konsolen-App (.NET Framework).

Deklarationen

Typdefinition	Beschreibung
`queue::const_reference`	Der Typ eines konstanten Verweises auf ein Element.
`queue::container_type`	Der Typ des zugrunde liegenden Containers.
`queue::difference_type`	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
`queue::generic_container`	Der Typ der generischen Schnittstelle für den Containeradapter.
`queue::generic_value`	Der Typ eines Elements für die generische Schnittstelle für den Containeradapter.
`queue::reference`	Der Typ eines Verweises auf ein Element.
`queue::size_type`	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
`queue::value_type`	Der Typ eines Elements.

Memberfunktion	Beschreibung
`queue::assign`	Ersetzt alle Elemente.
`queue::back`	Greift auf das letzte Element zu.
`queue::empty`	Testet, ob keine Elemente vorhanden sind.
`queue::front`	Greift auf das erste Element zu.
`queue::get_container`	Greift auf den zugrunde liegenden Container zu.
`queue::pop`	Entfernt das erste Element.
`queue::push`	Fügt ein neues letztes Element hinzu.
`queue::queue`	Erstellt ein container-Objekt.
`queue::size`	Ermittelt die Anzahl von Elementen.
`queue::to_array`	Kopiert die kontrollierte Sequenz in ein neues Array.

Eigenschaft	Beschreibung
`queue::back_item`	Greift auf das letzte Element zu.
`queue::front_item`	Greift auf das erste Element zu.

Operator	Beschreibung
`queue::operator=`	Ersetzt die kontrollierte Sequenz.
`operator!=` (Warteschlange)	Bestimmt, ob ein Objekt nicht mit einem `queue` anderen `queue` Objekt identisch ist.
`operator<` (Warteschlange)	Bestimmt, ob ein Objekt kleiner als ein `queue` anderes `queue` Objekt ist.
`operator<=` (Warteschlange)	Bestimmt, ob ein Objekt kleiner oder gleich einem `queue` anderen `queue` Objekt ist.
`operator==` (Warteschlange)	Bestimmt, ob ein Objekt mit einem `queue` anderen `queue` Objekt identisch ist.
`operator>` (Warteschlange)	Bestimmt, ob ein Objekt größer als ein `queue` anderes `queue` Objekt ist.
`operator>=` (Warteschlange)	Bestimmt, ob ein Objekt größer oder gleich einem `queue` anderen `queue` Objekt ist.

Schnittstellen

Schnittstelle	Beschreibung
ICloneable	Duplizieren Eines Objekts.
`IQueue<Value, Container>`	Verwalten Sie einen generischen Containeradapter.

Hinweise

Das Objekt reserviert und gibt Speicherplatz für die Sequenz frei, die es über einen zugrunde liegenden Container vom Typ Container steuert, der Elemente speichert Value und bei Bedarf wächst. Das Objekt schränkt den Zugriff ein, um nur das erste Element zu pushen und das letzte Element aufhängt, eine First-In-First-Out-Warteschlange (auch als FIFO-Warteschlange bezeichnet oder einfach eine Warteschlange) zu implementieren.

Member

`queue::assign`

Ersetzt alle Elemente.

Syntax

void assign(queue<Value, Container>% right);

Parameter

right
Containeradapter, der eingefügt werden soll.

Hinweise

Die Memberfunktion weist right.get_container() dem zugrunde liegenden Container zu. Sie verwenden es, um den gesamten Inhalt der Warteschlange zu ändern.

Beispiel

// cliext_queue_assign.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // assign a repetition of values
    Myqueue c2;
    c2.assign(c1);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
a b c

`queue::back`

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 in Denkhaftheit sein muss. Sie verwenden es, um auf das letzte Element zuzugreifen, wenn Sie wissen, dass ein Element vorhanden ist.

Beispiel

// cliext_queue_back.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents "a b c"
    for each (wchar_t elem in c1.get_container())
        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.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
back() = c
a b x

`queue::back_item`

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 in Denkhaftheit sein muss. Sie verwenden es, um das letzte Element zu lesen oder zu schreiben, wenn Sie wissen, dass ein Element vorhanden ist.

Beispiel

// cliext_queue_back_item.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents "a b c"
    for each (wchar_t elem in c1.get_container())
        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.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
back_item = c
a b x

`queue::const_reference`

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_queue_const_reference.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents "a b c"
    for (; !c1.empty(); c1.pop())
        {   // get a const reference to an element
        Myqueue::const_reference cref = c1.front();
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
}

a b c

`queue::container_type`

Der Typ des zugrunde liegenden Containers.

Syntax

typedef Container value_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Containerdar.

Beispiel

// cliext_queue_container_type.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents "a b c" using container_type
    Myqueue::container_type wc1 = c1.get_container();
    for each (wchar_t elem in wc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c

`queue::difference_type`

Die Typen eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int difference_type;

Hinweise

Der Typ beschreibt eine möglicherweise negative Elementanzahl.

Beispiel

// cliext_queue_difference_type.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // compute negative difference
    Myqueue::difference_type diff = c1.size();
    c1.push(L'd');
    c1.push(L'e');
    diff -= c1.size();
    System::Console::WriteLine("pushing 2 = {0}", diff);

    // compute positive difference
    diff = c1.size();
    c1.pop();
    c1.pop();
    c1.pop();
    diff -= c1.size();
    System::Console::WriteLine("popping 3 = {0}", diff);
    return (0);
}

a b c
pushing 2 = -2
popping 3 = 3

`queue::empty`

Testet, ob keine Elemente vorhanden sind.

Syntax

bool empty();

Hinweise

Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück. Dies entspricht size() == 0. Sie verwenden es, um zu testen, ob die Datei queue leer ist.

Beispiel

// cliext_queue_empty.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents "a b c"
    for each (wchar_t elem in c1.get_container())
        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.pop();
    c1.pop();
    c1.pop();
    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

`queue::front`

Greift auf das erste Element zu.

Syntax

reference front();

Hinweise

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

Beispiel

// cliext_queue_front.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display initial contents "a b c"
    for each (wchar_t elem in c1.get_container())
        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.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
front() = a
x b c

`queue::front_item`

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 in Denkhaftheit sein muss. Sie verwenden es, um das erste Element zu lesen oder zu schreiben, wenn Sie wissen, dass ein Element vorhanden ist.

Beispiel

// cliext_queue_front_item.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

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

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

a b c
front_item = a
x b c

`queue::generic_container`

Der Typ der generischen Schnittstelle für den Containeradapter.

Syntax

typedef Microsoft::VisualC::StlClr::IQueue<Value>
    generic_container;

Hinweise

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

Beispiel

// cliext_queue_generic_container.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

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

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

    // modify original and display generic
    c1.push(L'e');
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

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

`queue::generic_value`

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. (GValue ist entweder value_type oder value_type^ wenn value_type es sich um einen Verweistyp handelt.)

Beispiel

// cliext_queue_generic_value.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // get interface to container
    Myqueue::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display in order using generic_value
    for (; !gc1->empty(); gc1->pop())
        {
        Myqueue::generic_value elem = gc1->front();

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

a b c
a b c
a b c

`queue::get_container`

Greift auf den zugrunde liegenden Container zu.

Syntax

container_type^ get_container();

Hinweise

Die Memberfunktion gibt den zugrunde liegenden Container zurück. Sie verwenden sie, um die vom Containerwrapper auferlegten Einschränkungen zu umgehen.

Beispiel

// cliext_queue_get_container.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

a b c

`queue::operator=`

Ersetzt die kontrollierte Sequenz.

Syntax

queue <Value, Container>% operator=(queue <Value, Container>% right);

Parameter

right
Containeradapter, der kopiert werden soll.

Hinweise

Der Memberoperator kopiert right in das Objekt und gibt dann zurück *this. Sie können ihn verwenden, um die kontrollierte Sequenz durch eine Kopie der kontrollierten Sequenz in right zu ersetzen.

Beispiel

// cliext_queue_operator_as.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

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

a b c
a b c

`queue::pop`

Entfernt das erste Element.

Syntax

void pop();

Hinweise

Entfernt das erste Element der kontrollierten Sequenz, das nicht entsent werden muss.

Beispiel

// cliext_queue_pop.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

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

a b c
b c

`queue::push`

Fügt ein neues letztes Element hinzu.

Syntax

void push(value_type val);

Hinweise

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

Beispiel

// cliext_queue_push.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

a b c

`queue::queue`

Erstellt ein Containeradapterobjekt.

Syntax

queue();
queue(queue<Value, Container>% right);
queue(queue<Value, Container>^ right);
explicit queue(container_type% wrapped);

Parameter

right
Objekt, das kopiert werden soll.

wrapped
Umschlossener Container, der verwendet werden soll.

Hinweise

Der Konstruktor:

queue();

erstellt einen leeren umschlossenen Container. Sie verwenden sie, um eine leere anfängliche kontrollierte Sequenz anzugeben.

Der Konstruktor:

queue(queue<Value, Container>% right);

erstellt einen umschlossenen Container, der eine Kopie von right.get_container(). Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der sequenz ist, die queue vom Objekt rightgesteuert wird.

Der Konstruktor:

queue(queue<Value, Container>^ right);

erstellt einen umschlossenen Container, der eine Kopie von right->get_container(). Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der sequenz ist, die queue vom Objekt *rightgesteuert wird.

Der Konstruktor:

explicit queue(container_type wrapped);

verwendet den vorhandenen Container wrapped als umschlossenen Container. Sie verwenden es, um einen queue aus einem vorhandenen Container zu erstellen.

Beispiel

// cliext_queue_construct.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>
#include <cliext/list>

typedef cliext::queue<wchar_t> Myqueue;
typedef cliext::list<wchar_t> Mylist;
typedef cliext::queue<wchar_t, Mylist> Myqueue_list;
int main()
{
    // construct an empty container
    Myqueue c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    // construct from an underlying container
    Mylist v2(5, L'x');
    Myqueue_list c2(v2);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Myqueue_list c3(c2);
    for each (wchar_t elem in c3.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container through handle
    Myqueue_list c4(%c2);
    for each (wchar_t elem in c4.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

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

`queue::reference`

Der Typ eines Verweises auf ein Element.

Syntax

typedef value_type% reference;

Hinweise

Der Typ beschreibt einen Verweis auf ein Element.

Beispiel

// cliext_queue_reference.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // modify back of queue and redisplay
    Myqueue::reference ref = c1.back();
    ref = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
a b x

`queue::size`

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 eine Nichtzerogröße aufweist, lesen Sie empty().

Beispiel

// cliext_queue_size.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // pop an item and reinspect
    c1.pop();
    System::Console::WriteLine("size() = {0} after popping", c1.size());

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

a b c
size() = 3 starting with 3
size() = 2 after popping
size() = 4 after adding 2

`queue::size_type`

Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.

Syntax

typedef int size_type;

Hinweise

Der Typ beschreibt eine nicht negative Elementanzahl.

Beispiel

// cliext_queue_size_type.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // compute positive difference
    Myqueue::size_type diff = c1.size();
    c1.pop();
    c1.pop();
    diff -= c1.size();
    System::Console::WriteLine("size difference = {0}", diff);
    return (0);
}

a b c
size difference = 2

`queue::to_array`

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_queue_to_array.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    c1.push(L'd');
    for each (wchar_t elem in c1.get_container())
        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

`queue::value_type`

Der Typ eines Elements.

Syntax

typedef Value value_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Valuedar.

Beispiel

// cliext_queue_value_type.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display reversed contents "a b c" using value_type
    for (; !c1.empty(); c1.pop())
        {   // store element in value_type object
        Myqueue::value_type val = c1.front();

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

a b c

`operator!=` (Warteschlange)

Queue ungleicher Vergleich.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(left == right). Sie verwenden sie, um zu testen, ob left die Reihenfolge nicht identisch ist, als right wenn die beiden Warteschlangen Element nach Element verglichen werden.

Beispiel

// cliext_queue_operator_ne.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // assign to a new container
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        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<` (Warteschlange)

Queue kleiner als vergleich.

Syntax

template<typename Value,
    typename Container>
    bool operator<(queue<Value, Container>% left,
        queue<Value, Container>% 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 wird left->size() < right->size()zurückgegeben. Sie verwenden sie, um zu testen, ob left die beiden Warteschlangen nach right Element verglichen werden.

Beispiel

// cliext_queue_operator_lt.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // assign to a new container
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        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<=` (Warteschlange)

Queue kleiner oder gleicher Vergleich.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(right < left). Sie verwenden sie, um zu testen, ob left das Element nach Element nicht sortiert right wird, wenn die beiden Warteschlangen nach Element verglichen werden.

Beispiel

// cliext_queue_operator_le.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // assign to a new container
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

/    / display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        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==` (Warteschlange)

Queue gleicher Vergleich.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt "true" nur zurück, wenn die sequenzen gesteuert werden left und right dieselbe Länge aufweisen und für jede Position i, left[i] == right[i]. Sie verwenden sie, um zu testen, ob left die Reihenfolge der Reihenfolge entspricht, right wenn die beiden Warteschlangen nach Element verglichen werden.

Beispiel

// cliext_queue_operator_eq.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // assign to a new container
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        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>` (Warteschlange)

Queue größer als der Vergleich.

Syntax

template<typename Value,
    typename Container>
    bool operator>(queue<Value, Container>% left,
        queue<Value, Container>% 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 left die right beiden Warteschlangen nach Element verglichen werden.

Beispiel

// cliext_queue_operator_gt.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // assign to a new container
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        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>=` (Warteschlange)

Queue größer als oder gleicher Vergleich.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(left < right). Sie verwenden sie, um zu testen, ob left die right beiden Warteschlangen nach Element nicht sortiert werden.

Beispiel

// cliext_queue_operator_ge.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

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

    // assign to a new container
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        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

Freigeben über

queue (STL/CLR)

Syntax

Parameter

Anforderungen

Deklarationen

Schnittstellen

Hinweise

Member

queue::assign

Syntax

Parameter

Hinweise

Beispiel

queue::back

Syntax

Hinweise

Beispiel

queue::back_item

Syntax

Hinweise

Beispiel

queue::const_reference

Syntax

Hinweise

Beispiel

queue::container_type

Syntax

Hinweise

Beispiel

queue::difference_type

Syntax

Hinweise

Beispiel

queue::empty

Syntax

Hinweise

Beispiel

queue::front

Syntax

Hinweise

Beispiel

queue::front_item

Syntax

Hinweise

Beispiel

queue::generic_container

Syntax

Hinweise

Beispiel

queue::generic_value

Syntax

Hinweise

Beispiel

queue::get_container

Syntax

Hinweise

Beispiel

queue::operator=

Syntax

Parameter

Hinweise

Beispiel

queue::pop

Syntax

Hinweise

Beispiel

queue::push

Syntax

Hinweise

Beispiel

queue::queue

Syntax

Parameter

Hinweise

Beispiel

queue::reference

Syntax

Hinweise

Beispiel

`queue` (STL/CLR)

`queue::assign`

`queue::back`

`queue::back_item`

`queue::const_reference`

`queue::container_type`

`queue::difference_type`

`queue::empty`

`queue::front`

`queue::front_item`

`queue::generic_container`

`queue::generic_value`

`queue::get_container`

`queue::operator=`

`queue::pop`

`queue::push`

`queue::queue`

`queue::reference`

`queue::size`

`queue::size_type`

`queue::to_array`

`queue::value_type`

`operator!=` (Warteschlange)

`operator<` (Warteschlange)

`operator<=` (Warteschlange)

`operator==` (Warteschlange)

`operator>` (Warteschlange)

`operator>=` (Warteschlange)