priority_queue (STL/CLR)

La classe modello descrive un oggetto che controlla una sequenza ordinata di lunghezza variabile di elementi con accesso limitato. Usare l'adattatore priority_queue contenitore per gestire un contenitore sottostante come coda di priorità.

Nella descrizione seguente GValue , è uguale a Value a meno che quest'ultimo non sia un tipo ref, nel qual caso è Value^. Analogamente, GContainer è uguale a Container a meno che quest'ultimo non sia un tipo ref, nel qual caso è Container^.

Sintassi

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

Parametri

valore
Tipo di un elemento nella sequenza controllata.

Contenitore
Tipo del contenitore sottostante.

Requisiti

Intestazione:<cliext/queue>

Spazio dei nomi: cliext

Dichiarazioni

Definizione del tipo	Descrizione
priority_queue::const_reference (STL/CLR)	Tipo di un riferimento costante a un elemento.
priority_queue::container_type (STL/CLR)	Tipo del contenitore sottostante.
priority_queue::difference_type (STL/CLR)	Tipo di una distanza Signed tra due elementi.
priority_queue::generic_container (STL/CLR)	Tipo dell'interfaccia generica per l'adattatore contenitore.
priority_queue::generic_value (STL/CLR)	Tipo di un elemento per l'interfaccia generica per l'adattatore contenitore.
priority_queue::reference (STL/CLR)	Tipo di un riferimento a un elemento.
priority_queue::size_type (STL/CLR)	Tipo di una distanza Signed tra due elementi.
priority_queue::value_compare (STL/CLR)	Delegato di ordinamento per due elementi.
priority_queue::value_type (STL/CLR)	Tipo di un elemento.

Funzione membro	Descrizione
priority_queue::assign (STL/CLR)	Sostituisce tutti gli elementi.
priority_queue::empty (STL/CLR)	Verifica se sono presenti o meno degli elementi.
priority_queue::get_container (STL/CLR)	Accede al contenitore sottostante.
priority_queue::pop (STL/CLR)	Rimuove l'elemento hghest-priority.
priority_queue::priority_queue (STL/CLR)	Costruisce un oggetto contenitore.
priority_queue::push (STL/CLR)	Aggiunge un nuovo elemento.
priority_queue::size (STL/CLR)	Conta il numero di elementi.
priority_queue::top (STL/CLR)	Accede all'elemento con priorità più alta.
priority_queue::to_array (STL/CLR)	Copia la sequenza controllata in una nuova matrice.
priority_queue::value_comp (STL/CLR)	Copia il delegato di ordinamento per due elementi.

Proprietà	Descrizione
priority_queue::top_item (STL/CLR)	Accede all'elemento con priorità più alta.

Operatore	Descrizione
priority_queue::operator= (STL/CLR)	Sostituisce la sequenza controllata.

Interfacce

Interfaccia	Descrizione
ICloneable	Duplicare un oggetto .
Valore IPriorityQueue<, Contenitore>	Mantenere l'adattatore contenitore generico.

Osservazioni:

L'oggetto alloca e libera l'archiviazione per la sequenza che controlla tramite un contenitore sottostante, di tipo Container, che archivia Value gli elementi e aumenta su richiesta. Mantiene la sequenza ordinata come heap, con l'elemento con priorità più alta (l'elemento superiore) facilmente accessibile e rimovibile. L'oggetto limita l'accesso al push di nuovi elementi ed estrae solo l'elemento con priorità più alta, implementando una coda di priorità.

L'oggetto ordina la sequenza che controlla chiamando un oggetto delegato archiviato di tipo priority_queue::value_compare (STL/CLR). È possibile specificare l'oggetto delegato archiviato quando si costruisce il priority_queue; se non si specifica alcun oggetto delegato, il valore predefinito è il confronto operator<(value_type, value_type). Per accedere a questo oggetto archiviato, chiamare la funzione membro priority_queue::value_comp (STL/CLR).()

Tale oggetto delegato deve imporre un ordinamento rigido debole sui valori di tipo priority_queue::value_type (STL/CLR). Ciò significa che per due chiavi X e Y:

value_comp()(X, Y) restituisce lo stesso risultato booleano in ogni chiamata.

Se value_comp()(X, Y) è true, value_comp()(Y, X) deve essere false.

Se value_comp()(X, Y) è true, X viene detto che deve essere ordinato prima Ydi .

Se !value_comp()(X, Y) && !value_comp()(Y, X) è true, X e Y viene detto di avere un ordinamento equivalente.

Per qualsiasi elemento X che precede Y nella sequenza controllata, key_comp()(Y, X) è false. Per l'oggetto delegato predefinito, le chiavi non diminuiscono mai nel valore.

L'elemento con priorità più alta è quindi uno degli elementi che non vengono ordinati prima di qualsiasi altro elemento.

Poiché il contenitore sottostante mantiene gli elementi ordinati come heap:

Il contenitore deve supportare iteratori ad accesso casuale.

Gli elementi con ordinamento equivalente possono essere visualizzati in un ordine diverso da quello di cui sono stati inseriti. L'ordinamento non è stabile.

Pertanto, i candidati per il contenitore sottostante includono deque (STL/CLR) e vector (STL/CLR).

Membri

priority_queue::assign (STL/CLR)

Sostituisce tutti gli elementi.

Sintassi

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

Parametri

right
Adattatore contenitore da inserire.

Osservazioni:

La funzione membro viene right.get_container() assegnata al contenitore sottostante. Viene usato per modificare l'intero contenuto della coda.

Esempio

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

Tipo di un riferimento costante a un elemento.

Sintassi

typedef value_type% const_reference;

Osservazioni:

Il tipo descrive un riferimento costante a un elemento.

Esempio

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

Tipo del contenitore sottostante.

Sintassi

typedef Container value_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Container.

Esempio

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

Tipi di distanza con segno tra due elementi.

Sintassi

typedef int difference_type;

Osservazioni:

Il tipo descrive un numero di elementi potenzialmente negativo.

Esempio

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

Verifica se sono presenti o meno degli elementi.

Sintassi

bool empty();

Osservazioni:

La funzione membro restituisce true per una sequenza controllata vuota. Equivale a priority_queue::size (STL/CLR).() == 0 Viene usato per verificare se il priority_queue è vuoto.

Esempio

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

Tipo dell'interfaccia generica per il contenitore.

Sintassi

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

Osservazioni:

Il tipo descrive l'interfaccia generica per questa classe adattatore contenitore modello.

Esempio

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

Tipo di un elemento da usare con l'interfaccia generica per il contenitore.

Sintassi

typedef GValue generic_value;

Osservazioni:

Il tipo descrive un oggetto di tipo GValue che descrive il valore dell'elemento archiviato da usare con l'interfaccia generica per questa classe contenitore modello. (GValue è value_type o value_type^ se value_type è un tipo ref.

Esempio

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

Accede al contenitore sottostante.

Sintassi

container_type get_container();

Osservazioni:

La funzione membro restituisce il contenitore sottostante. È possibile usarlo per ignorare le restrizioni imposte dal wrapper del contenitore.

Esempio

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

Sostituisce la sequenza controllata.

Sintassi

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

Parametri

right
Adattatore contenitore da copiare.

Osservazioni:

L'operatore membro copia direttamente nell'oggetto , quindi restituisce *this. Lo si usa per sostituire la sequenza controllata con una copia della sequenza controllata a destra.

Esempio

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

Rimuove l'elemento proirity più alto.

Sintassi

void pop();

Osservazioni:

La funzione membro rimuove l'elemento con priorità più alta della sequenza controllata, che deve essere non vuoto. È possibile usarlo per abbreviare la coda di un elemento nella parte posteriore.

Esempio

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

Costruisce un oggetto adattatore contenitore.

Sintassi

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

Parametri

Cont
Contenitore da copiare.

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

Pred
Predicato di ordinamento per la sequenza controllata.

right
Oggetto o un intervallo da inserire.

Osservazioni:

Costruttore:

priority_queue();

crea un contenitore incapsulato vuoto, con il predicato di ordinamento predefinito. Viene usato per specificare una sequenza controllata iniziale vuota, con il predicato di ordinamento predefinito.

Costruttore:

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

crea un contenitore di cui è stato eseguito il wrapping che è una copia di right.get_container(), con il predicato right.value_comp()di ordinamento . Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dal diritto dell'oggetto coda, con lo stesso predicato di ordinamento.

Costruttore:

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

crea un contenitore di cui è stato eseguito il wrapping che è una copia di right->get_container(), con il predicato right->value_comp()di ordinamento . Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto *rightqueue , con lo stesso predicato di ordinamento.

Costruttore:

explicit priority_queue(value_compare^ pred);

crea un contenitore di cui è stato eseguito il wrapping vuoto, con il predicato di ordinamento pred. Viene usato per specificare una sequenza controllata iniziale vuota, con il predicato di ordinamento specificato.

Costruttore:

priority_queue(value_compare^ pred, container_type cont);

crea un contenitore incapsulato vuoto, con il predicato di ordinamento pred, quindi esegue il push di tutti gli elementi di cont Viene usato per specificare una sequenza controllata iniziale da un contenitore esistente, con il predicato di ordinamento specificato.

Costruttore:

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

crea un contenitore incapsulato vuoto, con il predicato di ordinamento predefinito, quindi esegue il push della sequenza [first, last). Viene usato per specificare una sequenza controllata iniziale da un'eqeuence specificata, con il predicato di ordinamento specificato.

Costruttore:

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

crea un contenitore incapsulato vuoto, con il predicato di ordinamento pred, quindi esegue il push della sequenza [first, last). Viene usato per specificare una sequenza controllata iniziale da una seqeuence specificata, con il predicato di ordinamento specificato.

Costruttore:

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

crea un contenitore incapsulato vuoto, con il predicato di ordinamento pred, quindi esegue il push di tutti gli elementi di cont più la sequenza [first, last). Viene usato per specificare una sequenza controllata iniziale da un contenitore esistente e una seqeuence specificata, con il predicato di ordinamento specificato.

Esempio

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

Aggiunge un nuovo elemento.

Sintassi

void push(value_type val);

Osservazioni:

La funzione membro inserisce un elemento con valore val nella sequenza controllata e riordina la sequenza controllata per mantenere la disciplina heap. È possibile usarlo per aggiungere un altro elemento alla coda.

Esempio

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

Tipo di un riferimento a un elemento.

Sintassi

typedef value_type% reference;

Osservazioni:

Il tipo descrive un riferimento a un elemento.

Esempio

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

Conta il numero di elementi.

Sintassi

size_type size();

Osservazioni:

La funzione membro restituisce la lunghezza della sequenza controllata. Viene usato per determinare il numero di elementi attualmente presenti nella sequenza controllata. Se è importante sapere se la sequenza ha dimensioni diverse da zero, vedere priority_queue::empty (STL/CLR).If all you care about is if the sequence has notzero size, see priority_queue::empty (STL/CLR)().

Esempio

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

Tipo di distanza con segno tra due elementi.

Sintassi

typedef int size_type;

Osservazioni:

Il tipo descrive un numero di elementi non negativi.

Esempio

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

Copia la sequenza controllata in una nuova matrice.

Sintassi

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

Osservazioni:

La funzione membro restituisce una matrice contenente la sequenza controllata. Viene usato per ottenere una copia della sequenza controllata in formato matrice.

Esempio

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

Accede all'elemento con priorità più alta.

Sintassi

reference top();

Osservazioni:

La funzione membro restituisce un riferimento all'elemento top (con priorità più alta) della sequenza controllata, che deve essere non vuoto. Viene usato per accedere all'elemento con priorità più alta, quando si sa che esiste.

Esempio

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

Accede all'elemento con priorità più alta.

Sintassi

property value_type back_item;

Osservazioni:

La proprietà accede all'elemento superiore (con priorità più alta) della sequenza controllata, che deve essere non vuoto. È possibile usarlo per leggere o scrivere l'elemento con priorità più alta, quando si sa che esiste.

Esempio

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

Copia il delegato di ordinamento per due elementi.

Sintassi

value_compare^ value_comp();

Osservazioni:

La funzione membro restituisce il delegato di ordinamento utilizzato per ordinare la sequenza controllata. Viene usato per confrontare due valori.

Esempio

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

Delegato di ordinamento per due valori.

Sintassi

binary_delegate<value_type, value_type, int> value_compare;

Osservazioni:

Il tipo è un sinonimo del delegato che determina se il primo argomento viene ordinato prima del secondo.

Esempio

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

Tipo di un elemento.

Sintassi

typedef Value value_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Value.

Esempio

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