`queue` (STL/CLR)

In de sjabloonklasse wordt een object beschreven dat een verschillende lengtereeks bepaalt van elementen met first-in first-out-toegang. Gebruik de containeradapter queue om een onderliggende container als wachtrij te beheren.

In de volgende beschrijving is GValue hetzelfde als Value, tenzij het laatste een verwijzingstype is, in dat geval Value^. Op dezelfde manier is GContainer hetzelfde als Container, tenzij het laatste een ref-type is, in welk geval het Container^is.

Syntaxis

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

Parameters

Value
Het type element in de gecontroleerde reeks.

Container
Het type van de onderliggende container.

Eisen

koptekst:<cliext/queue>

naamruimte:cliext

Belangrijk

Als u de voorbeelden in dit onderwerp wilt compileren, moet u ervoor zorgen dat u C++/CLI-ondersteuning hebt geïnstalleerd, zoals beschreven in C++/CLI-ondersteuning installeren in Visual Studio 2022. Maak voor het projecttype een CLR Console-app (.NET Framework).

Verklaringen

Typedefinitie	Beschrijving
`queue::const_reference`	Het type constante verwijzing naar een element.
`queue::container_type`	Het type van de onderliggende container.
`queue::difference_type`	Het type ondertekende afstand tussen twee elementen.
`queue::generic_container`	Het type van de algemene interface voor de containeradapter.
`queue::generic_value`	Het type element voor de algemene interface voor de containeradapter.
`queue::reference`	Het type verwijzing naar een element.
`queue::size_type`	Het type ondertekende afstand tussen twee elementen.
`queue::value_type`	Het type element.

Lid, functie	Beschrijving
`queue::assign`	Vervangt alle elementen.
`queue::back`	Hiermee opent u het laatste element.
`queue::empty`	Test of er geen elementen aanwezig zijn.
`queue::front`	Hiermee opent u het eerste element.
`queue::get_container`	Hiermee opent u de onderliggende container.
`queue::pop`	Hiermee verwijdert u het eerste element.
`queue::push`	Hiermee voegt u een nieuw laatste element toe.
`queue::queue`	Maakt een containerobject.
`queue::size`	Telt het aantal elementen.
`queue::to_array`	Hiermee kopieert u de gecontroleerde reeks naar een nieuwe matrix.

Eigenschap	Beschrijving
`queue::back_item`	Hiermee opent u het laatste element.
`queue::front_item`	Hiermee opent u het eerste element.

Bediener	Beschrijving
`queue::operator=`	Vervangt de gecontroleerde volgorde.
`operator!=` (wachtrij)	Bepaalt of een `queue` object niet gelijk is aan een ander `queue`-object.
`operator<` (wachtrij)	Bepaalt of een `queue` object kleiner is dan een ander `queue` object.
`operator<=` (wachtrij)	Bepaalt of een `queue` object kleiner is dan of gelijk is aan een ander `queue` object.
`operator==` (wachtrij)	Bepaalt of een `queue` object gelijk is aan een ander `queue`-object.
`operator>` (wachtrij)	Bepaalt of een `queue` object groter is dan een ander `queue` object.
`operator>=` (wachtrij)	Bepaalt of een `queue` object groter is dan of gelijk is aan een ander `queue` object.

Interfaces

Interface	Beschrijving
ICloneable	Een object dupliceren.
`IQueue<Value, Container>`	Algemene containeradapter onderhouden.

Opmerkingen

Het object wijst en maakt opslag vrij voor de volgorde die het beheert via een onderliggende container van het type Container die Value elementen opslaat en op aanvraag toeneemt. Het object beperkt de toegang tot het pushen van het eerste element en het poppen van het laatste element, het implementeren van een first-in first-out wachtrij (ook wel een FIFO-wachtrij of gewoon een wachtrij genoemd).

Leden

`queue::assign`

Vervangt alle elementen.

Syntaxis

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

Parameters

right
Containeradapter die moet worden ingevoegd.

Opmerkingen

De lidfunctie wijst right.get_container() toe aan de onderliggende container. U kunt deze gebruiken om de volledige inhoud van de wachtrij te wijzigen.

Voorbeeld

// 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`

Hiermee opent u het laatste element.

Syntaxis

reference back();

Opmerkingen

De lidfunctie retourneert een verwijzing naar het laatste element van de gecontroleerde reeks, die niet-betrouwbaar moet zijn. U gebruikt het om toegang te krijgen tot het laatste element, wanneer u weet dat er een bestaat.

Voorbeeld

// 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`

Hiermee opent u het laatste element.

Syntaxis

property value_type back_item;

Opmerkingen

De eigenschap heeft toegang tot het laatste element van de gecontroleerde reeks, die niet-betrouwbaar moet zijn. U gebruikt het om het laatste element te lezen of te schrijven, wanneer u weet dat er een bestaat.

Voorbeeld

// 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`

Het type constante verwijzing naar een element.

Syntaxis

typedef value_type% const_reference;

Opmerkingen

Het type beschrijft een constante verwijzing naar een element.

Voorbeeld

// 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`

Het type van de onderliggende container.

Syntaxis

typedef Container value_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Container.

Voorbeeld

// 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`

De typen van een ondertekende afstand tussen twee elementen.

Syntaxis

typedef int difference_type;

Opmerkingen

Het type beschrijft mogelijk een negatief aantal elementen.

Voorbeeld

// 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`

Test of er geen elementen aanwezig zijn.

Syntaxis

bool empty();

Opmerkingen

De lidfunctie retourneert waar voor een lege beheerde reeks. Het is gelijk aan size() == 0. U gebruikt deze om te testen of de queue leeg is.

Voorbeeld

// 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`

Hiermee opent u het eerste element.

Syntaxis

reference front();

Opmerkingen

De lidfunctie retourneert een verwijzing naar het eerste element van de gecontroleerde reeks, die niet-mptig moet zijn. U gebruikt het om toegang te krijgen tot het eerste element, wanneer u weet dat er een bestaat.

Voorbeeld

// 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`

Hiermee opent u het eerste element.

Syntaxis

property value_type front_item;

Opmerkingen

De eigenschap krijgt toegang tot het eerste element van de gecontroleerde reeks, wat geenmpty moet zijn. U gebruikt het om het eerste element te lezen of te schrijven, wanneer u weet dat er een bestaat.

Voorbeeld

// 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`

Het type van de algemene interface voor de containeradapter.

Syntaxis

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

Opmerkingen

Het type beschrijft de algemene interface voor deze containeradapterklasse van de sjabloon.

Voorbeeld

// 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`

Het type element dat moet worden gebruikt met de algemene interface voor de container.

Syntaxis

typedef GValue generic_value;

Opmerkingen

Het type beschrijft een object van het type GValue dat de waarde van het opgeslagen element beschrijft voor gebruik met de algemene interface voor deze sjablooncontainerklasse. (GValue is value_type of value_type^ als value_type een verwijzingstype is.)

Voorbeeld

// 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`

Hiermee opent u de onderliggende container.

Syntaxis

container_type^ get_container();

Opmerkingen

De lidfunctie retourneert de onderliggende container. U gebruikt deze om de beperkingen te omzeilen die door de container-wrapper worden opgelegd.

Voorbeeld

// 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=`

Vervangt de gecontroleerde volgorde.

Syntaxis

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

Parameters

right
Containeradapter die moet worden gekopieerd.

Opmerkingen

De lidoperator kopieert right naar het object en retourneert vervolgens *this. U gebruikt deze om de gecontroleerde reeks te vervangen door een kopie van de gecontroleerde reeks in right.

Voorbeeld

// 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`

Hiermee verwijdert u het eerste element.

Syntaxis

void pop();

Opmerkingen

Hiermee verwijdert u het eerste element van de gecontroleerde reeks, die geenmpty moet zijn.

Voorbeeld

// 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`

Hiermee voegt u een nieuw laatste element toe.

Syntaxis

void push(value_type val);

Opmerkingen

De lidfunctie voegt een element met waarde toe val aan het einde van de wachtrij. U gebruikt dit om een element toe te voegen aan de wachtrij.

Voorbeeld

// 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`

Maakt een containeradapterobject.

Syntaxis

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

Parameters

right
Te kopiëren object.

wrapped
Verpakte container die moet worden gebruikt.

Opmerkingen

De constructor:

queue();

maakt een lege verpakte container. U gebruikt deze om een lege initiële gecontroleerde reeks op te geven.

De constructor:

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

maakt een verpakte container die een kopie van right.get_container()is. U gebruikt deze om een initiële gecontroleerde reeks op te geven die een kopie is van de reeks die wordt beheerd door het queue-object right.

De constructor:

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

maakt een verpakte container die een kopie van right->get_container()is. U gebruikt deze om een initiële gecontroleerde reeks op te geven die een kopie is van de reeks die wordt beheerd door het queue-object *right.

De constructor:

explicit queue(container_type wrapped);

gebruikt de bestaande container wrapped als de verpakte container. U gebruikt deze om een queue te maken op basis van een bestaande container.

Voorbeeld

// 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`

Het type verwijzing naar een element.

Syntaxis

typedef value_type% reference;

Opmerkingen

Het type beschrijft een verwijzing naar een element.

Voorbeeld

// 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`

Telt het aantal elementen.

Syntaxis

size_type size();

Opmerkingen

De lidfunctie retourneert de lengte van de gecontroleerde reeks. U gebruikt deze om het aantal elementen te bepalen dat zich momenteel in de gecontroleerde volgorde bevindt. Zie empty()als u alleen wilt weten of de reeks een niet-nulgrootte heeft.

Voorbeeld

// 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`

Het type ondertekende afstand tussen twee elementen.

Syntaxis

typedef int size_type;

Opmerkingen

Het type beschrijft een niet-negatief aantal elementen.

Voorbeeld

// 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`

Hiermee kopieert u de gecontroleerde reeks naar een nieuwe matrix.

Syntaxis

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

Opmerkingen

De lidfunctie retourneert een matrix die de gecontroleerde reeks bevat. U gebruikt deze om een kopie van de gecontroleerde reeks in matrixvorm te verkrijgen.

Voorbeeld

// 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`

Het type element.

Syntaxis

typedef Value value_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Value.

Voorbeeld

// 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!=` (wachtrij)

Queue niet gelijk aan vergelijking.

Syntaxis

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

Parameters

left
Container links om te vergelijken.

right
Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(left == right). U gebruikt deze om te testen of left niet hetzelfde is als right wanneer de twee wachtrijen per element worden vergeleken.

Voorbeeld

// 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<` (wachtrij)

Queue kleiner dan vergelijking.

Syntaxis

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

Parameters

left
Container links om te vergelijken.

right
Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert waar als, voor de laagste positie i waarvoor !(right[i] < left[i]) het ook waar is dat left[i] < right[i]. Anders wordt left->size() < right->size()geretourneerd. U gebruikt deze om te testen of left vóór right is gerangschikt wanneer de twee wachtrijen per element worden vergeleken.

Voorbeeld

// 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<=` (wachtrij)

Queue vergelijking kleiner dan of gelijk.

Syntaxis

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

Parameters

left
Container links om te vergelijken.

right
Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(right < left). U gebruikt deze om te testen of left na right niet is besteld wanneer de twee wachtrijen per element worden vergeleken.

Voorbeeld

// 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==` (wachtrij)

Queue gelijke vergelijking.

Syntaxis

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

Parameters

left
Container links om te vergelijken.

right
Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert alleen waar als de reeksen die worden beheerd door left en right dezelfde lengte hebben en voor elke positie i, left[i] == right[i]. U gebruikt deze om te testen of left hetzelfde is als right wanneer de twee wachtrijen per element worden vergeleken.

Voorbeeld

// 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>` (wachtrij)

Queue groter dan vergelijking.

Syntaxis

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

Parameters

left
Container links om te vergelijken.

right
Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert right < left. U gebruikt deze functie om te testen of left na right is geordend wanneer de twee wachtrijen per element worden vergeleken.

Voorbeeld

// 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>=` (wachtrij)

Queue groter dan of gelijk aan vergelijking.

Syntaxis

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

Parameters

left
Container links om te vergelijken.

right
Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(left < right). U gebruikt deze om te testen of left niet is besteld voordat right wanneer de twee wachtrijen per element worden vergeleken.

Voorbeeld

// 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

Feedback

Is deze pagina nuttig?

Last updated on 2025-11-07

Delen via

queue (STL/CLR)

Syntaxis

Parameters

Eisen

Verklaringen

Interfaces

Opmerkingen

Leden

queue::assign

Syntaxis

Parameters

Opmerkingen

Voorbeeld

queue::back

Syntaxis

Opmerkingen

Voorbeeld

queue::back_item

Syntaxis

Opmerkingen

Voorbeeld

queue::const_reference

Syntaxis

Opmerkingen

Voorbeeld

queue::container_type

Syntaxis

Opmerkingen

Voorbeeld

queue::difference_type

Syntaxis

Opmerkingen

Voorbeeld

queue::empty

Syntaxis

Opmerkingen

Voorbeeld

queue::front

Syntaxis

Opmerkingen

Voorbeeld

queue::front_item

Syntaxis

Opmerkingen

Voorbeeld

queue::generic_container

Syntaxis

Opmerkingen

Voorbeeld

queue::generic_value

Syntaxis

Opmerkingen

Voorbeeld

queue::get_container

Syntaxis

Opmerkingen

Voorbeeld

queue::operator=

Syntaxis

Parameters

Opmerkingen

Voorbeeld

queue::pop

Syntaxis

Opmerkingen

Voorbeeld

queue::push

Syntaxis

Opmerkingen

Voorbeeld

queue::queue

Syntaxis

Parameters

Opmerkingen

Voorbeeld

queue::reference

Syntaxis

Opmerkingen

Voorbeeld

`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!=` (wachtrij)

`operator<` (wachtrij)

`operator<=` (wachtrij)

`operator==` (wachtrij)

`operator>` (wachtrij)

`operator>=` (wachtrij)