priority_queue (STL/CLR)

Článek
10/12/2023

Třída šablony popisuje objekt, který řídí různou délku uspořádanou sekvenci prvků s omezeným přístupem. Adaptér priority_queue kontejneru slouží ke správě základního kontejneru jako prioritní fronty.

V následujícím popisu je stejná jako Hodnota, GValue pokud druhý typ odkazu, v takovém případě je Value^to . Podobně je stejný jako Kontejner, GContainer pokud druhý typ odkazu, v takovém případě je Container^to .

Syntaxe

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

Parametry

Hodnota
Typ elementu v řízené sekvenci

Kontejner
Typ podkladového kontejneru.

Požadavky

Header:<cliext/queue>

Namespace: cliext

Deklarace

Definice typu	Popis
priority_queue::const_reference (STL/CLR)	Typ konstantního odkazu na prvek
priority_queue::container_type (STL/CLR)	Typ podkladového kontejneru.
priority_queue::difference_type (STL/CLR)	Typ vzdálenosti se znaménkem mezi dvěma prvky
priority_queue::generic_container (STL/CLR)	Typ obecného rozhraní pro adaptér kontejneru.
priority_queue::generic_value (STL/CLR)	Typ elementu pro obecné rozhraní pro adaptér kontejneru.
priority_queue::reference (STL/CLR)	Typ odkazu na prvek
priority_queue::size_type (STL/CLR)	Typ vzdálenosti se znaménkem mezi dvěma prvky
priority_queue::value_compare (STL/CLR)	Delegát řazení pro dva prvky.
priority_queue::value_type (STL/CLR)	Typ prvku

Členská funkce	Popis
priority_queue::assign (STL/CLR)	Nahradí všechny prvky.
priority_queue::empty (STL/CLR)	Zkouší, zda nejsou přítomny žádné prvky.
priority_queue::get_container (STL/CLR)	Přistupuje k podkladovému kontejneru.
priority_queue::pop (STL/CLR)	Odebere prvek s nejvyšší prioritou.
priority_queue::priority_queue (STL/CLR)	Sestaví objekt kontejneru.
priority_queue::push (STL/CLR)	Přidá nový prvek.
priority_queue::size (STL/CLR)	Spočítá počet prvků.
priority_queue::top (STL/CLR)	Přistupuje k prvku s nejvyšší prioritou.
priority_queue::to_array (STL/CLR)	Zkopíruje řízenou sekvenci do nového pole.
priority_queue::value_comp (STL/CLR)	Zkopíruje delegáta řazení pro dva prvky.

Vlastnost	Popis
priority_queue::top_item (STL/CLR)	Přistupuje k prvku s nejvyšší prioritou.

Operátor	Popis
priority_queue::operator= (STL/CLR)	Nahradí řízenou sekvenci.

Rozhraní

Rozhraní	Popis
ICloneable	Duplikovat objekt
IPriorityQueue<Value, Container>	Udržujte obecný adaptér kontejneru.

Poznámky

Objekt přidělí a uvolní úložiště pro sekvenci, kterou řídí prostřednictvím základního kontejneru, typu Container, který ukládá Value prvky a roste na vyžádání. Udržuje pořadí seřazené jako haldu, přičemž prvek nejvyšší priority (horní prvek) je snadno přístupný a vyměnitelný. Objekt omezuje přístup k nasdílení nových prvků a přeskočení pouze elementu s nejvyšší prioritou, který implementuje frontu priority.

Objekt objednává sekvenci, kterou řídí voláním uloženého delegáta objektu typu priority_queue::value_compare (STL/CLR). Při vytváření priority_queue můžete určit uložený objekt delegáta; Pokud zadáte žádný objekt delegáta, výchozí hodnota je porovnání operator<(value_type, value_type). K tomuto uloženému objektu se dostanete voláním členské funkce priority_queue::value_comp (STL/CLR).()

Takový objekt delegáta musí mít přísné slabé řazení hodnot typu priority_queue::value_type (STL/CLR). To znamená, že pro všechny dva klíče X a Y:

value_comp()(X, Y) vrátí stejný logický výsledek při každém volání.

Pokud value_comp()(X, Y) je pravda, value_comp()(Y, X) musí být false.

Pokud value_comp()(X, Y) je pravda, pak X je řečeno, že je objednán před Y.

Pokud !value_comp()(X, Y) && !value_comp()(Y, X) je pravda, znamená to Y X, že mají ekvivalentní řazení.

Pro každý prvek X , který předchází Y řízené sekvenci, key_comp()(Y, X) je false. (U výchozího objektu delegáta klíče nikdy nezmenší hodnotu.)

Prvek nejvyšší priority je tedy jedním z prvků, které nejsou seřazeny před žádným jiným prvkem.

Vzhledem k tomu, že základní kontejner uchovává prvky seřazené jako haldu:

Kontejner musí podporovat iterátory náhodného přístupu.

Prvky s ekvivalentním řazením mohou být přepnuty v jiném pořadí, než byly nasdíleny. (Řazení není stabilní.)

Kandidáti pro podkladový kontejner proto zahrnují deque (STL/CLR) a vector (STL/CLR).

Členové

priority_queue::assign (STL/CLR)

Nahradí všechny prvky.

Syntaxe

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

Parametry

Vpravo
Adaptér kontejneru, který se má vložit.

Poznámky

Členová funkce se přiřadí right.get_container() k podkladovému kontejneru. Použijete ho ke změně celého obsahu fronty.

Příklad

// 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 konstantního odkazu na prvek

Syntaxe

typedef value_type% const_reference;

Poznámky

Typ popisuje konstantní odkaz na prvek.

Příklad

// 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 podkladového kontejneru.

Syntaxe

typedef Container value_type;

Poznámky

Typ je synonymem pro parametr Containeršablony .

Příklad

// 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 podepsané vzdálenosti mezi dvěma prvky.

Syntaxe

typedef int difference_type;

Poznámky

Typ popisuje pravděpodobně záporný počet prvků.

Příklad

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

Zkouší, zda nejsou přítomny žádné prvky.

Syntaxe

bool empty();

Poznámky

Členová funkce vrátí hodnotu true pro prázdnou řízenou sekvenci. Je ekvivalentní priority_queue::size (STL/CLR).() == 0 Použijete ho k otestování, jestli je priority_queue prázdný.

Příklad

// 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 obecného rozhraní pro kontejner.

Syntaxe

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

Poznámky

Typ popisuje obecné rozhraní pro tuto třídu adaptéru kontejneru šablony.

Příklad

// 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 pro použití s obecným rozhraním kontejneru.

Syntaxe

typedef GValue generic_value;

Poznámky

Typ popisuje objekt typu GValue , který popisuje uloženou hodnotu elementu pro použití s obecným rozhraním pro tuto třídu kontejneru šablony. (GValue je buď value_type nebo value_type^ je-li value_type typ odkazu.)

Příklad

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

Přistupuje k podkladovému kontejneru.

Syntaxe

container_type get_container();

Poznámky

Členová funkce vrátí základní kontejner. Použijete ho k obejití omezení uložených obálkou kontejneru.

Příklad

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

Nahradí řízenou sekvenci.

Syntaxe

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

Parametry

Vpravo
Adaptér kontejneru, který se má zkopírovat.

Poznámky

Operátor člena zkopíruje právo na objekt a pak vrátí *this. Slouží k nahrazení řízené sekvence kopií řízené sekvence vpravo.

Příklad

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

Odebere prvek nejvyšší proirity.

Syntaxe

void pop();

Poznámky

Členová funkce odebere prvek nejvyšší priority řízené sekvence, který musí být neprázdný. Můžete ji použít ke zkrácení fronty o jeden prvek na zadní straně.

Příklad

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

Vytvoří objekt adaptéru kontejneru.

Syntaxe

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

Pokrač
Kontejner, který se má zkopírovat.

první
Začátek oblasti, která se má vložit.

poslední
Konec oblasti, která se má vložit.

před
Řazení predikátu pro řízenou sekvenci

Vpravo
Objekt nebo oblast, které chcete vložit.

Poznámky

Konstruktor:

priority_queue();

vytvoří prázdný zabalený kontejner s výchozím predikátem řazení. Slouží k určení prázdné počáteční řízené sekvence s výchozím predikátem řazení.

Konstruktor:

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

vytvoří zabalený kontejner, který je kopií right.get_container(), s predikátem right.value_comp()řazení . Slouží k určení počáteční řízené sekvence, která je kopií sekvence řízené objektem fronty vpravo, se stejným predikátem řazení.

Konstruktor:

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

vytvoří zabalený kontejner, který je kopií right->get_container(), s predikátem right->value_comp()řazení . Slouží k určení počáteční řízené sekvence, která je kopií sekvence řízené objektem *rightfronty , se stejným predikátem řazení.

Konstruktor:

explicit priority_queue(value_compare^ pred);

vytvoří prázdný zabalený kontejner s predikátem řazení. Použijete ho k určení prázdné počáteční řízené sekvence se zadaným predikátem řazení.

Konstruktor:

priority_queue(value_compare^ pred, container_type cont);

vytvoří prázdný zabalený kontejner s predikátem řazení a potom nasdílí všechny prvky cont Použijete ho k určení počáteční řízené sekvence z existujícího kontejneru se zadaným predikátem řazení.

Konstruktor:

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

vytvoří prázdný zabalený kontejner s výchozím predikátem řazení a potom nasdílí sekvenci [first, last). Použijete ho k určení počáteční řízené sekvence ze zadaného eqeuence se zadaným predikátem řazení.

Konstruktor:

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

vytvoří prázdný zabalený kontejner s predikátem řazení a potom nasdílí sekvenci [first, last). Slouží k určení počáteční řízené sekvence ze zadané seqeuence se zadaným predikátem řazení.

Konstruktor:

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

vytvoří prázdný zabalený kontejner s predikátem řazení predikátu a pak nasdílí všechny prvky cont a sekvenci [first, last). Použijete ho k určení počáteční řízené sekvence z existujícího kontejneru a zadané seqeuence se zadaným predikátem řazení.

Příklad

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

Přidá nový prvek.

Syntaxe

void push(value_type val);

Poznámky

Členová funkce vloží prvek s hodnotou val do řízené sekvence a změní pořadí řízené sekvence tak, aby zachovala disciplínu haldy. Použijete ho k přidání dalšího prvku do fronty.

Příklad

// 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 odkazu na prvek

Syntaxe

typedef value_type% reference;

Poznámky

Typ popisuje odkaz na prvek.

Příklad

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

Spočítá počet prvků.

Syntaxe

size_type size();

Poznámky

Členová funkce vrátí délku řízené sekvence. Použijete ho k určení počtu prvků aktuálně v řízené sekvenci. Pokud vás zajímá, jestli má sekvence nenulovou velikost, podívejte se na priority_queue::empty (STL/CLR).()

Příklad

// 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 podepsané vzdálenosti mezi dvěma prvky.

Syntaxe

typedef int size_type;

Poznámky

Typ popisuje nezáporný počet prvků.

Příklad

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

Zkopíruje řízenou sekvenci do nového pole.

Syntaxe

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

Poznámky

Členová funkce vrátí matici obsahující řízenou sekvenci. Použijete ji k získání kopie řízené sekvence ve formuláři pole.

Příklad

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

Přistupuje k prvku s nejvyšší prioritou.

Syntaxe

reference top();

Poznámky

Členová funkce vrátí odkaz na prvek nejvyšší (nejvyšší priority) řízené sekvence, která musí být neprázdná. Použijete ho pro přístup k prvku s nejvyšší prioritou, pokud víte, že existuje.

Příklad

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

Přistupuje k prvku s nejvyšší prioritou.

Syntaxe

property value_type back_item;

Poznámky

Vlastnost přistupuje k prvku nejvyšší (nejvyšší priorita) řízené sekvence, která musí být neprázdná. Používáte ho ke čtení nebo zápisu elementu s nejvyšší prioritou, pokud víte, že existuje.

Příklad

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

Zkopíruje delegáta řazení pro dva prvky.

Syntaxe

value_compare^ value_comp();

Poznámky

Členová funkce vrátí delegáta řazení, který se používá k seřazení řízené sekvence. Použijete ho k porovnání dvou hodnot.

Příklad

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

Delegát řazení pro dvě hodnoty.

Syntaxe

binary_delegate<value_type, value_type, int> value_compare;

Poznámky

Typ je synonymem pro delegáta, který určuje, zda je první argument seřazen před sekundou.

Příklad

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

Syntaxe

typedef Value value_type;

Poznámky

Typ je synonymem pro hodnotu parametru šablony.

Příklad

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

Sdílet prostřednictvím

priority_queue (STL/CLR)

Syntaxe

Parametry

Požadavky

Deklarace

Rozhraní

Poznámky

Členové

priority_queue::assign (STL/CLR)

Syntaxe

Parametry

Poznámky

Příklad

priority_queue::const_reference (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::container_type (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::difference_type (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::empty (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::generic_container (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::generic_value (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::get_container (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::operator= (STL/CLR)

Syntaxe

Parametry

Poznámky

Příklad

priority_queue::pop (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::priority_queue (STL/CLR)

Syntaxe

Parametry

Poznámky

Příklad

priority_queue::push (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::reference (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::size (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::size_type (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::to_array (STL/CLR)

Syntaxe

Poznámky

Příklad

priority_queue::top (STL/CLR)

Syntaxe

Poznámky

Příklad