priority_queue (STL/CLR)

Klasa szablonu opisuje obiekt, który kontroluje uporządkowaną sekwencję elementów o różnej długości, która ma ograniczony dostęp. Adapter kontenera priority_queue służy do zarządzania kontenerem bazowym jako kolejką priorytetową.

W poniższym opisie wartość jest taka sama jak Wartość, GValue chyba że ten ostatni jest typem ref, w takim przypadku jest to Value^. Podobnie jest taki sam jak kontener, GContainer chyba że ten ostatni jest typem ref, w takim przypadku jest to Container^.

Składnia

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

Parametry

Wartość
Typ elementu w kontrolowanej sekwencji.

kontener
Typ kontenera bazowego.

Wymagania

Header:<cliext/queue>

Przestrzeń nazw: cliext

Deklaracje

Definicja typu	opis
priority_queue::const_reference (STL/CLR)	Typ stałego odwołania do elementu.
priority_queue::container_type (STL/CLR)	Typ kontenera bazowego.
priority_queue::difference_type (STL/CLR)	Typ odległości ze znakiem między dwoma elementami.
priority_queue::generic_container (STL/CLR)	Typ interfejsu ogólnego dla karty kontenera.
priority_queue::generic_value (STL/CLR)	Typ elementu dla interfejsu ogólnego dla karty kontenera.
priority_queue::reference (STL/CLR)	Typ odwołania do elementu.
priority_queue::size_type (STL/CLR)	Typ odległości ze znakiem między dwoma elementami.
priority_queue::value_compare (STL/CLR)	Delegat porządkowania dla dwóch elementów.
priority_queue::value_type (STL/CLR)	Typ elementu.

Funkcja elementów członkowskich	opis
priority_queue::assign (STL/CLR)	Zastępuje wszystkie elementy.
priority_queue::empty (STL/CLR)	Sprawdza, czy nie ma żadnych elementów.
priority_queue::get_container (STL/CLR)	Uzyskuje dostęp do bazowego kontenera.
priority_queue::pop (STL/CLR)	Usuwa element hghest-priority.
priority_queue::priority_queue (STL/CLR)	Konstruuje obiekt kontenera.
priority_queue::push (STL/CLR)	Dodaje nowy element.
priority_queue::size (STL/CLR)	Liczy liczbę elementów.
priority_queue::top (STL/CLR)	Uzyskuje dostęp do elementu o najwyższym priorytcie.
priority_queue::to_array (STL/CLR)	Kopiuje kontrolowaną sekwencję do nowej tablicy.
priority_queue::value_comp (STL/CLR)	Kopiuje delegat porządkowania dla dwóch elementów.

Właściwości	opis
priority_queue::top_item (STL/CLR)	Uzyskuje dostęp do elementu o najwyższym priorytcie.

Operator	opis
priority_queue::operator= (STL/CLR)	Zastępuje kontrolowaną sekwencję.

Interfejsy

Interfejs	opis
ICloneable	Duplikuj obiekt.
IPriorityQueue<Value, Container>	Obsługa ogólnej karty kontenera.

Uwagi

Obiekt przydziela i zwalnia magazyn dla sekwencji, którą kontroluje za pośrednictwem bazowego kontenera Containertypu , który przechowuje Value elementy i rośnie na żądanie. Utrzymuje sekwencję uporządkowaną jako stertę z elementem o najwyższym priorytcie (górnym elemencie) łatwo dostępnym i wymiennym. Obiekt ogranicza dostęp do wypychania nowych elementów i wyświetlania tylko najwyższego priorytetu elementu, implementując kolejkę priorytetu.

Obiekt porządkuje sekwencję sterując nią przez wywołanie przechowywanego obiektu delegata typu priority_queue::value_compare (STL/CLR).The object orders it controls by wywołać przechowywany obiekt delegata typu priority_queue::value_compare (STL/CLR). Przechowywany obiekt delegata można określić podczas konstruowania priority_queue; Jeśli nie określisz obiektu delegata, wartością domyślną jest porównanie operator<(value_type, value_type). Uzyskujesz dostęp do tego przechowywanego obiektu, wywołując funkcję składową priority_queue::value_comp (STL/CLR).()

Taki obiekt delegata musi narzucić ścisłe słabe porządkowanie wartości typu priority_queue::value_type (STL/CLR). Oznacza to, że dla dwóch kluczy X i Y:

value_comp()(X, Y) Zwraca ten sam wynik logiczny dla każdego wywołania.

Jeśli value_comp()(X, Y) wartość ma wartość true, value_comp()(Y, X) to musi być fałsz.

Jeśli value_comp()(X, Y) to prawda, mówi się, X że należy zamówić przed Y.

Jeśli !value_comp()(X, Y) && !value_comp()(Y, X) to prawda, to X i Y mówi się, że mają równoważne kolejność.

W przypadku każdego elementu X , który poprzedza Y się w kontrolowanej sekwencji, key_comp()(Y, X) jest false. (W przypadku domyślnego obiektu delegata klucze nigdy nie zmniejszają wartości).

Element o najwyższym priorytcie jest zatem jednym z elementów, które nie są uporządkowane przed żadnym innym elementem.

Ponieważ podstawowy kontener przechowuje elementy uporządkowane jako sterta:

Kontener musi obsługiwać iteratory dostępu losowego.

Elementy z równoważną kolejnością mogą być zwinięte w innej kolejności niż zostały wypchnięte. (Kolejność nie jest stabilna).

W związku z tym kandydaci do bazowego kontenera obejmują deque (STL/CLR) i wektor (STL/CLR).

Członkowie

priority_queue::assign (STL/CLR)

Zastępuje wszystkie elementy.

Składnia

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

Parametry

Prawo
Adapter kontenera do wstawienia.

Uwagi

Funkcja składowa przypisuje right.get_container() do kontenera bazowego. Służy do zmiany całej zawartości kolejki.

Przykład

// cliext_priority_queue_assign.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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
    Mypriority_queue c2;
    c2.assign(c1);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b
c a b

priority_queue::const_reference (STL/CLR)

Typ stałego odwołania do elementu.

Składnia

typedef value_type% const_reference;

Uwagi

Typ opisuje stałe odwołanie do elementu.

Przykład

// cliext_priority_queue_const_reference.cpp
// compile with: /clr
#include <cliext/queue>

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

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

c b a

priority_queue::container_type (STL/CLR)

Typ kontenera bazowego.

Składnia

typedef Container value_type;

Uwagi

Typ jest synonimem parametru Containerszablonu .

Przykład

// cliext_priority_queue_container_type.cpp
// compile with: /clr
#include <cliext/queue>

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

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

c a b

priority_queue::difference_type (STL/CLR)

Typy podpisanej odległości między dwoma elementami.

Składnia

typedef int difference_type;

Uwagi

Typ opisuje prawdopodobnie ujemną liczbę elementów.

Przykład

// cliext_priority_queue_difference_type.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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
    Mypriority_queue::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);
    }

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

priority_queue::empty (STL/CLR)

Sprawdza, czy nie ma żadnych elementów.

Składnia

bool empty();

Uwagi

Funkcja składowa zwraca wartość true dla pustej kontrolowanej sekwencji. Jest to odpowiednik priority_queue::size (STL/CLR)() == 0. Służy do testowania, czy priority_queue jest pusta.

Przykład

// cliext_priority_queue_empty.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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);
    }

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

priority_queue::generic_container (STL/CLR)

Typ interfejsu ogólnego dla kontenera.

Składnia

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

Uwagi

Typ opisuje ogólny interfejs dla tej klasy adaptera kontenera szablonu.

Przykład

// cliext_priority_queue_generic_container.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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
    Mypriority_queue::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);
    }

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

priority_queue::generic_value (STL/CLR)

Typ elementu do użycia z interfejsem ogólnym kontenera.

Składnia

typedef GValue generic_value;

Uwagi

Typ opisuje obiekt typu GValue , który opisuje przechowywaną wartość elementu do użycia z interfejsem ogólnym dla tej klasy kontenera szablonu. (GValue jest value_type albo jeśli value_type^value_type jest typem ref).

Przykład

// cliext_priority_queue_generic_value.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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
    Mypriority_queue::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

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

c a b
c a b
c b a

priority_queue::get_container (STL/CLR)

Uzyskuje dostęp do bazowego kontenera.

Składnia

container_type get_container();

Uwagi

Funkcja składowa zwraca kontener źródłowy. Służy do obejścia ograniczeń narzuconych przez otokę kontenera.

Przykład

// cliext_priority_queue_get_container.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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);
    }

c a b

priority_queue::operator= (STL/CLR)

Zastępuje kontrolowaną sekwencję.

Składnia

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

Parametry

Prawo
Adapter kontenera do skopiowania.

Uwagi

Operator elementu członkowskiego kopiuje prawo do obiektu, a następnie zwraca wartość *this. Służy do zastępowania kontrolowanej sekwencji kopią kontrolowanej sekwencji po prawej stronie.

Przykład

// cliext_priority_queue_operator_as.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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
    Mypriority_queue c2;
    c2 = c1;
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b
c a b

priority_queue::pop (STL/CLR)

Usuwa element o najwyższej proirity.

Składnia

void pop();

Uwagi

Funkcja składowa usuwa element o najwyższym priorytcie kontrolowanej sekwencji, który musi być niepusty. Służy do skrócenia kolejki przez jeden element z tyłu.

Przykład

// cliext_priority_queue_pop.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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);
    }

c a b
b a

priority_queue::priority_queue (STL/CLR)

Tworzy obiekt adaptera kontenera.

Składnia

priority_queue();
priority_queue(priority_queue<Value, Container> right);
priority_queue(priority_queue<Value, Container> right);
explicit priority_queue(value_compare^ pred);
priority_queue(value_compare^ pred, container_type% cont);
template<typename InIt>
    priority_queue(InIt first, InIt last);
template<typename InIt>
    priority_queue(InIt first, InIt last,
        value_compare^ pred);
template<typename InIt>
    priority_queue(InIt first, InIt last,
        value_compare^ pred, container_type% cont);

Parametry

Cd
Kontener do skopiowania.

Pierwszym
Początek zakresu do wstawienia.

Ostatnio
Koniec zakresu do wstawienia.

pred
Kolejność predykatu dla kontrolowanej sekwencji.

Prawo
Obiekt lub zakres do wstawienia.

Uwagi

Konstruktor:

priority_queue();

Tworzy pusty kontener opakowany z domyślnym predykatem porządkowania. Służy do określania pustej początkowej kontrolowanej sekwencji z domyślnym predykatem porządkowania.

Konstruktor:

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

Tworzy opakowany kontener, który jest kopią right.get_container()elementu , z predykatem right.value_comp()porządkowania . Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez obiekt kolejki po prawej stronie z tym samym predykatem porządkowania.

Konstruktor:

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

Tworzy opakowany kontener, który jest kopią right->get_container()elementu , z predykatem right->value_comp()porządkowania . Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez obiekt *rightkolejki , z tym samym predykatem porządkowania.

Konstruktor:

explicit priority_queue(value_compare^ pred);

Tworzy pusty kontener opakowany z predykatem porządkowania. Służy do określania pustej początkowej kontrolowanej sekwencji z określonym predykatem porządkowania.

Konstruktor:

priority_queue(value_compare^ pred, container_type cont);

Tworzy pusty kontener opakowany z predykatem porządkowania, a następnie wypycha wszystkie elementy elementu cont Służy do określania początkowej kontrolowanej sekwencji z istniejącego kontenera z określonym predykatem porządkowania.

Konstruktor:

template<typename InIt> priority_queue(InIt first, InIt last);

Tworzy pusty kontener opakowany z domyślnym predykatem porządkowania, a następnie wypycha sekwencję [first, last). Służy do określania początkowej kontrolowanej sekwencji z określonego równika z określonym predykatem porządkowania.

Konstruktor:

template<typename InIt> priority_queue(InIt first, InIt last, value_compare^ pred);

Tworzy pusty kontener opakowany z predykatem porządkowania, a następnie wypycha sekwencję [first, last). Służy do określania początkowej kontrolowanej sekwencji z określonej seqeuence z określonym predykatem porządkowania.

Konstruktor:

template<typename InIt> priority_queue(InIt first, InIt last, value_compare^ pred, container_type% cont);

Tworzy pusty kontener opakowany z predykatem porządkowania, a następnie wypycha wszystkie elementy cont plus sekwencję [first, last). Służy do określania początkowej kontrolowanej sekwencji z istniejącego kontenera i określonej seqeuence z określonym predykatem porządkowania.

Przykład

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

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
typedef cliext::deque<wchar_t> Mydeque;
int main()
    {
// construct an empty container
    Mypriority_queue c1;
    Mypriority_queue::container_type^ wc1 = c1.get_container();
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');
    for each (wchar_t elem in wc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule
    Mypriority_queue c2 = cliext::greater<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    for each (wchar_t elem in wc1)
        c2.push(elem);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an ordering rule by copying an underlying container
    Mypriority_queue c2x =
        gcnew Mypriority_queue(cliext::greater<wchar_t>(), *wc1);
   for each (wchar_t elem in c2x.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range
    Mypriority_queue c3(wc1->begin(), wc1->end());
    for each (wchar_t elem in c3.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Mypriority_queue c4(wc1->begin(), wc1->end(),
        cliext::greater<wchar_t>());
    for each (wchar_t elem in c4.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range, another container, and an ordering rule
    Mypriority_queue c5(wc1->begin(), wc1->end(),
        cliext::greater<wchar_t>(), *wc1);
    for each (wchar_t elem in c5.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct from a generic container
    Mypriority_queue c6(c3);
    for each (wchar_t elem in c6.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

    // construct with an ordering rule, by copying an underlying container
    Mypriority_queue c8 =
        gcnew Mypriority_queue(cliext::greater<wchar_t>(), *wc1);
    for each (wchar_t elem in c8.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

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

priority_queue::push (STL/CLR)

Dodaje nowy element.

Składnia

void push(value_type val);

Uwagi

Funkcja składowa wstawia element z wartością val do kontrolowanej sekwencji i zmienia kolejność kontrolowanej sekwencji w celu zachowania dyscypliny stertowania. Służy do dodawania innego elementu do kolejki.

Przykład

// cliext_priority_queue_push.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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);
    }

c a b

priority_queue::reference (STL/CLR)

Typ odwołania do elementu.

Składnia

typedef value_type% reference;

Uwagi

Typ opisuje odwołanie do elementu.

Przykład

// cliext_priority_queue_reference.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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 top of priority_queue and redisplay
    Mypriority_queue::reference ref = c1.top();
    ref = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c a b
x a b

priority_queue::size (STL/CLR)

Liczy liczbę elementów.

Składnia

size_type size();

Uwagi

Funkcja składowa zwraca długość kontrolowanej sekwencji. Służy do określania liczby elementów aktualnie w kontrolowanej sekwencji. Jeśli chodzi o to, czy sekwencja ma rozmiar inny niżzerowy, zobacz priority_queue::empty (STL/CLR)().

Przykład

// cliext_priority_queue_size.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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);
    }

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

priority_queue::size_type (STL/CLR)

Typ podpisanej odległości między dwoma elementami.

Składnia

typedef int size_type;

Uwagi

Typ opisuje nieujemną liczbę elementów.

Przykład

// cliext_priority_queue_size_type.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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
    Mypriority_queue::size_type diff = c1.size();
    c1.pop();
    c1.pop();
    diff -= c1.size();
    System::Console::WriteLine("size difference = {0}", diff);
    return (0);
    }

c a b
size difference = 2

priority_queue::to_array (STL/CLR)

Kopiuje kontrolowaną sekwencję do nowej tablicy.

Składnia

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

Uwagi

Funkcja składowa zwraca tablicę zawierającą kontrolowaną sekwencję. Służy do uzyskiwania kopii kontrolowanej sekwencji w postaci tablicy.

Przykład

// cliext_priority_queue_to_array.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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);
    }

d c b a
c a b

priority_queue::top (STL/CLR)

Uzyskuje dostęp do elementu o najwyższym priorytcie.

Składnia

reference top();

Uwagi

Funkcja składowa zwraca odwołanie do najwyższego (najwyższego priorytetu) elementu kontrolowanej sekwencji, który musi być niepusty. Służy do uzyskiwania dostępu do elementu o najwyższym priorytcie, gdy wiadomo, że istnieje.

Przykład

// cliext_priority_queue_top.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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("top() = {0}", c1.top());

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

priority_queue::top_item (STL/CLR)

Uzyskuje dostęp do elementu o najwyższym priorytcie.

Składnia

property value_type back_item;

Uwagi

Właściwość uzyskuje dostęp do najwyższego (najwyższego priorytetu) elementu kontrolowanej sekwencji, który musi być niepusty. Służy do odczytywania lub zapisywania elementu o najwyższym priorytcie, gdy wiadomo, że istnieje.

Przykład

// cliext_priority_queue_top_item.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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("top_item = {0}", c1.top_item);

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

c a b
top_item = c
x a b

priority_queue::value_comp (STL/CLR)

Kopiuje delegat porządkowania dla dwóch elementów.

Składnia

value_compare^ value_comp();

Uwagi

Funkcja składowa zwraca delegata porządkowania używanego do porządkowania kontrolowanej sekwencji. Służy do porównywania dwóch wartości.

Przykład

// cliext_priority_queue_value_comp.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    Mypriority_queue::value_compare^ vcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        vcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        vcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        vcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mypriority_queue c2 = cliext::greater<wchar_t>();
    vcomp = c2.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        vcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        vcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        vcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

priority_queue::value_compare (STL/CLR)

Delegat porządkowania dla dwóch wartości.

Składnia

binary_delegate<value_type, value_type, int> value_compare;

Uwagi

Typ jest synonimem delegata, który określa, czy pierwszy argument jest uporządkowany przed drugim.

Przykład

// cliext_priority_queue_value_compare.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue c1;
    Mypriority_queue::value_compare^ vcomp = c1.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        vcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        vcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        vcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Mypriority_queue c2 = cliext::greater<wchar_t>();
    vcomp = c2.value_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        vcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        vcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        vcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = False
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

priority_queue::value_type (STL/CLR)

Typ elementu.

Składnia

typedef Value value_type;

Uwagi

Typ jest synonimem wartości parametru szablonu.

Przykład

// cliext_priority_queue_value_type.cpp
// compile with: /clr
#include <cliext/queue>

typedef cliext::priority_queue<wchar_t> Mypriority_queue;
int main()
    {
    Mypriority_queue 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
        Mypriority_queue::value_type val = c1.top();

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

c b a