`queue` (STL/CLR)

Artikel
2025-03-11

Mallklassen beskriver ett objekt som styr en varierande längdsekvens av element som har första-i-först-ut-åtkomst. Använd containerkortet queue för att hantera en underliggande container som en kö.

I följande beskrivning är GValue samma som Value om inte det senare är en referenstyp, i vilket fall det är Value^. På samma sätt är GContainer samma som Container om inte det senare är en referenstyp, i vilket fall det är Container^.

Syntax

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

Parametrar

Value
Typen av ett element i den kontrollerade sekvensen.

Container
Typen av den underliggande containern.

Krav

rubrik:<cliext/queue>

namnområde:cliext

Viktig

Om du vill kompilera exemplen i det här avsnittet kontrollerar du att du har installerat C++/CLI-stöd enligt beskrivningen i Installera C++/CLI-stöd i Visual Studio 2022. För projekttypen skapar du en CLR-konsolapp (.NET Framework).

Deklarationer

Typdefinition	Beskrivning
`queue::const_reference`	Typen av en konstant referens till ett element.
`queue::container_type`	Typen av den underliggande containern.
`queue::difference_type`	Typen av ett signerat avstånd mellan två element.
`queue::generic_container`	Typ av det generiska gränssnittet för containerkortet.
`queue::generic_value`	Typ av element för det generiska gränssnittet för containerkortet.
`queue::reference`	Typen av referens till ett element.
`queue::size_type`	Typen av ett signerat avstånd mellan två element.
`queue::value_type`	Typ av element.

Medlemsfunktion	Beskrivning
`queue::assign`	Ersätter alla element.
`queue::back`	Öppnar det sista elementet.
`queue::empty`	Testar om det inte finns några element.
`queue::front`	Öppnar det första elementet.
`queue::get_container`	Öppnar den underliggande containern.
`queue::pop`	Tar bort det första elementet.
`queue::push`	Lägger till ett nytt sista element.
`queue::queue`	Skapar ett containerobjekt.
`queue::size`	Räknar antalet element.
`queue::to_array`	Kopierar den kontrollerade sekvensen till en ny matris.

Egenskap	Beskrivning
`queue::back_item`	Öppnar det sista elementet.
`queue::front_item`	Öppnar det första elementet.

Operatör	Beskrivning
`queue::operator=`	Ersätter den kontrollerade sekvensen.
`operator!=` (kö)	Avgör om ett `queue` objekt inte är lika med ett annat `queue` objekt.
`operator<` (kö)	Avgör om ett `queue` objekt är mindre än ett annat `queue` objekt.
`operator<=` (kö)	Avgör om ett `queue` objekt är mindre än eller lika med ett annat `queue` objekt.
`operator==` (kö)	Avgör om ett `queue` objekt är lika med ett annat `queue` objekt.
`operator>` (kö)	Avgör om ett `queue` objekt är större än ett annat `queue` objekt.
`operator>=` (kö)	Avgör om ett `queue` objekt är större än eller lika med ett annat `queue` objekt.

Gränssnitt

Gränssnitt	Beskrivning
ICloneable	Duplicera ett objekt.
`IQueue<Value, Container>`	Underhålla ett allmänt containerkort.

Anmärkningar

Objektet allokerar och frigör lagring för den sekvens som det styr genom en underliggande container av typen Container som lagrar Value element och växer på begäran. Objektet begränsar åtkomsten till att bara push-överföra det första elementet och poppa det sista elementet, implementera en första-i-först-ut-kö (även kallat en FIFO-kö eller helt enkelt en kö).

Medlemmar

`queue::assign`

Ersätter alla element.

Syntax

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

Parametrar

right
Containerkort som ska infogas.

Anmärkningar

Medlemsfunktionen tilldelar right.get_container() till den underliggande containern. Du använder den för att ändra hela innehållet i kön.

Exempel

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

Öppnar det sista elementet.

Syntax

reference back();

Anmärkningar

Medlemsfunktionen returnerar en referens till det sista elementet i den kontrollerade sekvensen, som måste vara icke-bakåtstymtom. Du använder det för att komma åt det sista elementet när du vet att det finns ett.

Exempel

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

Öppnar det sista elementet.

Syntax

property value_type back_item;

Anmärkningar

Egenskapen kommer åt det sista elementet i den kontrollerade sekvensen, som måste vara icke-lydigt. Du använder det för att läsa eller skriva det sista elementet när du vet att det finns ett.

Exempel

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

Typen av en konstant referens till ett element.

Syntax

typedef value_type% const_reference;

Anmärkningar

Typen beskriver en konstant referens till ett element.

Exempel

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

Typen av den underliggande containern.

Syntax

typedef Container value_type;

Anmärkningar

Typen är en synonym för mallparametern Container.

Exempel

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

Typerna av ett signerat avstånd mellan två element.

Syntax

typedef int difference_type;

Anmärkningar

Typen beskriver ett eventuellt negativt elementantal.

Exempel

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

Testar om det inte finns några element.

Syntax

bool empty();

Anmärkningar

Medlemsfunktionen returnerar true för en tom kontrollerad sekvens. Det motsvarar size() == 0. Du använder den för att testa om queue är tom.

Exempel

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

Öppnar det första elementet.

Syntax

reference front();

Anmärkningar

Medlemsfunktionen returnerar en referens till det första elementet i den kontrollerade sekvensen, som måste vara icke-bakåtstymtom. Du använder det för att komma åt det första elementet när du vet att det finns ett.

Exempel

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

Öppnar det första elementet.

Syntax

property value_type front_item;

Anmärkningar

Egenskapen kommer åt det första elementet i den kontrollerade sekvensen, som måste vara icke-lydigt. Du använder det för att läsa eller skriva det första elementet när du vet att det finns ett.

Exempel

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

Typ av det generiska gränssnittet för containerkortet.

Syntax

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

Anmärkningar

Typen beskriver det allmänna gränssnittet för den här mallcontainerkortklassen.

Exempel

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

Typen av ett element som ska användas med det allmänna gränssnittet för containern.

Syntax

typedef GValue generic_value;

Anmärkningar

Typen beskriver ett objekt av typen GValue som beskriver det lagrade elementvärdet för användning med det allmänna gränssnittet för den här mallcontainerklassen. (GValue är antingen value_type eller value_type^ om value_type är en referenstyp.)

Exempel

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

Öppnar den underliggande containern.

Syntax

container_type^ get_container();

Anmärkningar

Medlemsfunktionen returnerar den underliggande containern. Du använder den för att kringgå de begränsningar som införts av containeromslutningen.

Exempel

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

Ersätter den kontrollerade sekvensen.

Syntax

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

Parametrar

right
Containerkort som ska kopieras.

Anmärkningar

Medlemsoperatorn kopierar right till objektet och returnerar sedan *this. Du använder den för att ersätta den kontrollerade sekvensen med en kopia av den kontrollerade sekvensen i right.

Exempel

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

Tar bort det första elementet.

Syntax

void pop();

Anmärkningar

Tar bort det första elementet i den kontrollerade sekvensen, som måste vara icke-lydigt.

Exempel

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

Lägger till ett nytt sista element.

Syntax

void push(value_type val);

Anmärkningar

Medlemsfunktionen lägger till ett element med värdet val i slutet av kön. Du använder det för att lägga till ett element i kön.

Exempel

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

Konstruerar ett containerkortobjekt.

Syntax

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

Parametrar

right
Objekt som ska kopieras.

wrapped
Omsluten container som ska användas.

Anmärkningar

Konstruktorn:

queue();

skapar en tom omsluten container. Du använder den för att ange en tom inledande kontrollerad sekvens.

Konstruktorn:

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

skapar en omsluten container som är en kopia av right.get_container(). Du använder den för att ange en inledande kontrollerad sekvens som är en kopia av sekvensen som styrs av queue-objektet right.

Konstruktorn:

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

skapar en omsluten container som är en kopia av right->get_container(). Du använder den för att ange en inledande kontrollerad sekvens som är en kopia av sekvensen som styrs av queue-objektet *right.

Konstruktorn:

explicit queue(container_type wrapped);

använder den befintliga containern wrapped som den omslutna containern. Du använder den för att konstruera en queue från en befintlig container.

Exempel

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

Typen av referens till ett element.

Syntax

typedef value_type% reference;

Anmärkningar

Typen beskriver en referens till ett element.

Exempel

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

Räknar antalet element.

Syntax

size_type size();

Anmärkningar

Medlemsfunktionen returnerar längden på den kontrollerade sekvensen. Du använder den för att fastställa antalet element som för närvarande finns i den kontrollerade sekvensen. Om allt du bryr dig om är om sekvensen har en icke-nollstorlek kan du läsa empty().

Exempel

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

Typen av ett signerat avstånd mellan två element.

Syntax

typedef int size_type;

Anmärkningar

Typen beskriver ett icke-negativt elementantal.

Exempel

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

Kopierar den kontrollerade sekvensen till en ny matris.

Syntax

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

Anmärkningar

Medlemsfunktionen returnerar en matris som innehåller den kontrollerade sekvensen. Du använder den för att hämta en kopia av den kontrollerade sekvensen i matrisform.

Exempel

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

Typ av element.

Syntax

typedef Value value_type;

Anmärkningar

Typen är en synonym för mallparametern Value.

Exempel

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

Queue inte lika med jämförelse.

Syntax

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

Parametrar

left
Vänster container att jämföra.

right
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar !(left == right). Du använder den för att testa om left inte sorteras på samma sätt som right när de två köerna jämförs element för element.

Exempel

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

Queue mindre än jämförelse.

Syntax

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

Parametrar

left
Vänster container att jämföra.

right
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar sant om, för den lägsta positionen i som !(right[i] < left[i]) är det också sant att left[i] < right[i]. Annars returneras left->size() < right->size(). Du använder den för att testa om left ordnas före right när de två köerna jämförs element för element.

Exempel

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

Queue mindre än eller lika med jämförelse.

Syntax

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

Parametrar

left
Vänster container att jämföra.

right
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar !(right < left). Du använder den för att testa om left inte sorteras efter right när de två köerna jämförs element för element.

Exempel

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

Queue likhetsjämförelse.

Syntax

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

Parametrar

left
Vänster container att jämföra.

right
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar endast sant om sekvenserna som styrs av left och right har samma längd och för varje position ileft[i] == right[i]. Du använder den för att testa om left sorteras på samma sätt som right när de två köerna jämförs element för element.

Exempel

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

Queue större än jämförelse.

Syntax

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

Parametrar

left
Vänster container att jämföra.

right
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar right < left. Du använder den för att testa om left sorteras efter right när de två köerna jämförs element för element.

Exempel

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

Queue större än eller lika med jämförelse.

Syntax

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

Parametrar

left
Vänster container att jämföra.

right
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar !(left < right). Du använder den för att testa om left inte ordnas innan right när de två köerna jämförs element för element.

Exempel

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

Dela via

queue (STL/CLR)

Syntax

Parametrar

Krav

Deklarationer

Gränssnitt

Anmärkningar

Medlemmar

queue::assign

Syntax

Parametrar

Anmärkningar

Exempel

queue::back

Syntax

Anmärkningar

Exempel

queue::back_item

Syntax

Anmärkningar

Exempel

queue::const_reference

Syntax

Anmärkningar

Exempel

queue::container_type

Syntax

Anmärkningar

Exempel

queue::difference_type

Syntax

Anmärkningar

Exempel

queue::empty

Syntax

Anmärkningar

Exempel

queue::front

Syntax

Anmärkningar

Exempel

queue::front_item

Syntax

Anmärkningar

Exempel

queue::generic_container

Syntax

Anmärkningar

Exempel

queue::generic_value

Syntax

Anmärkningar

Exempel

queue::get_container

Syntax

Anmärkningar

Exempel

queue::operator=

Syntax

Parametrar

Anmärkningar

Exempel

queue::pop

Syntax

Anmärkningar

Exempel

queue::push

Syntax

Anmärkningar

Exempel

queue::queue

Syntax

Parametrar

Anmärkningar

Exempel

queue::reference

Syntax

Anmärkningar

Exempel

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

`operator<` (kö)

`operator<=` (kö)

`operator==` (kö)

`operator>` (kö)

`operator>=` (kö)