priority_queue (STL/CLR)

A classe de modelo descreve um objeto que controla uma sequência ordenada de tamanho variável de elementos que têm acesso limitado. Use o adaptador de contêiner priority_queue para gerenciar um contêiner subjacente como uma fila de prioridade.

Na descrição abaixo, GValue é o mesmo que Value, a menos que o último seja do tipo ref, caso em que seria Value^. Da mesma forma, GContainer é o mesmo que Container, a menos que este último seja um tipo ref, nesse caso ele seria Container^.

Sintaxe

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

Parâmetros

Valor
O tipo de um elemento na sequência controlada.

Contêiner
O tipo do contêiner subjacente.

Requisitos

Cabeçalho:<cliext/queue>

Namespace: cliext

Declarações

Definição de tipo	Descrição
priority_queue::const_reference (STL/CLR)	O tipo de uma referência de constante para um elemento.
priority_queue::container_type (STL/CLR)	O tipo do contêiner subjacente.
priority_queue::difference_type (STL/CLR)	O tipo de uma distância com sinal entre dois elementos.
priority_queue::generic_container (STL/CLR)	O tipo de interface genérica para o adaptador de contêiner.
priority_queue::generic_value (STL/CLR)	O tipo de um elemento para a interface genérica para o adaptador de contêiner.
priority_queue::reference (STL/CLR)	O tipo de uma referência para um elemento.
priority_queue::size_type (STL/CLR)	O tipo de uma distância com sinal entre dois elementos.
priority_queue::value_compare (STL/CLR)	O delegado de ordenação para dois elementos.
priority_queue::value_type (STL/CLR)	O tipo de um elemento.

Função membro	Descrição
priority_queue::assign (STL/CLR)	Substitui todos os elementos.
priority_queue::empty (STL/CLR)	Testa se nenhum elemento está presente.
priority_queue::get_container (STL/CLR)	Acessa o contêiner subjacente.
priority_queue::pop (STL/CLR)	Remove o elemento de prioridade mais alta.
priority_queue::priority_queue (STL/CLR)	Constrói um objeto contêiner.
priority_queue::push (STL/CLR)	Adiciona um novo elemento.
priority_queue::size (STL/CLR)	Conta o número de elementos.
priority_queue::top (STL/CLR)	Acessa o elemento de prioridade mais alta.
priority_queue::to_array (STL/CLR)	Copia a sequência controlada para uma nova matriz.
priority_queue::value_comp (STL/CLR)	Copia o delegado de ordenação para dois elementos.

Propriedade	Descrição
priority_queue::top_item (STL/CLR)	Acessa o elemento de prioridade mais alta.

Operador	Descrição
priority_queue::operator= (STL/CLR)	Substitui a sequência controlada.

Interfaces

Interface	Descrição
ICloneable	Duplica um objeto.
IPriorityQueue<Value, Container>	Mantenha o adaptador de contêiner genérico.

Comentários

O objeto aloca e libera armazenamento para a sequência que controla por meio de um contêiner subjacente, do tipo Container, que armazena elementos Value e cresce sob demanda. Ele mantém a sequência ordenada como um heap, com o elemento de prioridade mais alta (o elemento superior) prontamente acessível e removível. O objeto restringe o acesso ao enfileiramento de novos elementos e ao desenfileiramento apenas do elemento de prioridade mais alta, implementando uma fila de prioridade.

O objeto ordena a sequência que controla chamando um objeto delegado armazenado do tipo priority_queue::value_compare (STL/CLR). Você pode especificar o objeto delegado armazenado ao construir a priority_queue; se não especificar nenhum objeto delegado, o padrão será a comparação operator<(value_type, value_type). Esse objeto armazenado é acessado chamando a função membro priority_queue::value_comp (STL/CLR)().

Esse objeto delegado deve impor uma ordenação fraca estrita em valores do tipo priority_queue::value_type (STL/CLR). Isso significa que, para duas chaves X e Y quaisquer:

value_comp()(X, Y) retorna o mesmo resultado booliano em cada chamada.

Se value_comp()(X, Y) for verdadeiro, value_comp()(Y, X) precisará ser falso.

Se value_comp()(X, Y) for verdadeiro, X será ordenado antes de Y.

Se !value_comp()(X, Y) && !value_comp()(Y, X) for verdadeiro, então X e Y terão ordenação equivalente.

Para qualquer elemento X que preceder Y na sequência controlada, key_comp()(Y, X) será falso. (Para o objeto delegado padrão, as chaves nunca diminuem em valor.)

O elemento de prioridade mais alta é, portanto, um dos elementos que não é ordenado antes de qualquer outro elemento.

Como o contêiner subjacente mantém os elementos ordenados como um heap:

O contêiner deve dar suporte a iteradores de acesso aleatório.

Elementos com ordenação equivalente podem ser desenfileirados em uma ordem diferente da que foram enfileirados. (A ordenação não é estável.)

Assim, os candidatos para o contêiner subjacente incluem deque (STL/CLR) e vetor (STL/CLR).

Membros

priority_queue::assign (STL/CLR)

Substitui todos os elementos.

Sintaxe

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

Parâmetros

direita
Adaptador de contêiner a ser inserido.

Comentários

A função membro atribui right.get_container() ao contêiner subjacente. Use-a para alterar todo o conteúdo da fila.

Exemplo

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

O tipo de uma referência de constante para um elemento.

Sintaxe

typedef value_type% const_reference;

Comentários

O tipo descreve uma referência de constante para um elemento.

Exemplo

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

O tipo do contêiner subjacente.

Sintaxe

typedef Container value_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloContainer.

Exemplo

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

Os tipos de uma distância com sinal entre dois elementos.

Sintaxe

typedef int difference_type;

Comentários

O tipo descreve uma contagem de elementos possivelmente negativa.

Exemplo

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

Testa se nenhum elemento está presente.

Sintaxe

bool empty();

Comentários

A função membro retorna verdadeiro para uma sequência controlada vazia. É equivalente a priority_queue::size (STL/CLR)() == 0. Você pode usá-la para testar se a priority_queue está vazia.

Exemplo

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

O tipo da interface genérica para o contêiner.

Sintaxe

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

Comentários

O tipo descreve a interface genérica para essa classe de adaptador de contêiner de modelo.

Exemplo

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

O tipo de um elemento para uso com a interface genérica do contêiner.

Sintaxe

typedef GValue generic_value;

Comentários

O tipo descreve um objeto de tipo GValue que mostra o valor do elemento armazenado a ser usado com a interface genérica para essa classe de contêiner de modelo. (GValue é value_type ou value_type^, se value_type for um tipo de ref.)

Exemplo

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

Acessa o contêiner subjacente.

Sintaxe

container_type get_container();

Comentários

A função membro retorna o contêiner subjacente. Use-a para ignorar as restrições impostas pelo wrapper de contêiner.

Exemplo

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

Substitui a sequência controlada.

Sintaxe

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

Parâmetros

direita
Adaptador de contêiner a ser copiado.

Comentários

O operador membro copia a direita para o objeto e retorna *this. Use-o para substituir a sequência controlada por uma cópia da sequência controlada na direita.

Exemplo

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

Remove o elemento de prioridade mais alta.

Sintaxe

void pop();

Comentários

A função membro remove o elemento de prioridade mais alta da sequência controlada, que não deve estar vazia. Você a usa para reduzir a fila em um elemento na parte de trás.

Exemplo

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

Constrói um objeto adaptador de contêiner.

Sintaxe

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

Parâmetros

cont
O contêiner a ser copiado.

first
Início do intervalo a ser inserido.

last
Fim do intervalo a ser inserido.

pred
Predicado de ordenação para a sequência controlada.

direita
Objeto ou intervalo a inserir.

Comentários

O construtor:

priority_queue();

cria um contêiner encapsulado vazio, com o predicado de ordenação padrão. Use para especificar uma sequência controlada inicial vazia, com o predicado de ordenação padrão.

O construtor:

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

cria um contêiner encapsulado que é uma cópia de right.get_container(), com o predicado de ordenação right.value_comp(). Use-o para especificar uma sequência controlada inicial que é uma cópia da sequência controlada pelo objeto de fila right, com o mesmo predicado de ordenação.

O construtor:

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

cria um contêiner encapsulado que é uma cópia de right->get_container(), com o predicado de ordenação right->value_comp(). Use-o para especificar uma sequência controlada inicial que é uma cópia da sequência controlada pelo objeto de fila *right, com o mesmo predicado de ordenação.

O construtor:

explicit priority_queue(value_compare^ pred);

cria um contêiner encapsulado vazio, com o predicado de ordenação pred. Use-o para especificar uma sequência controlada inicial vazia, com o predicado de ordenação especificado.

O construtor:

priority_queue(value_compare^ pred, container_type cont);

cria um contêiner encapsulado vazio, com o predicado de ordenação pred e, em seguida, enfileira todos os elementos de cont. Use-o para especificar uma sequência controlada inicial de um contêiner existente, com o predicado de ordenação especificado.

O construtor:

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

cria um contêiner encapsulado vazio, com o predicado de ordenação padrão e, em seguida, enfileira a sequência [first, last). Use-o para especificar uma sequência controlada inicial de uma sequência especificada, com o predicado de ordenação especificado.

O construtor:

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

cria um contêiner encapsulado vazio, com o predicado de ordenação pred e, em seguida, enfileira a sequência [first, last). Use-o para especificar uma sequência controlada inicial de uma sequência especificada, com o predicado de ordenação especificado.

O construtor:

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

cria um contêiner encapsulado vazio, com o predicado de ordenação pred e, em seguida, enfileira todos os elementos de cont mais a sequência [first, last). Use-o para especificar uma sequência controlada inicial de um contêiner existente e de uma sequência especificada, com o predicado de ordenação especificado.

Exemplo

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

Adiciona um novo elemento.

Sintaxe

void push(value_type val);

Comentários

A função membro insere um elemento com valor val na sequência controlada e a reordena para manter a disciplina de heap. Você a usa para adicionar outro elemento à fila.

Exemplo

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

O tipo de uma referência para um elemento.

Sintaxe

typedef value_type% reference;

Comentários

O tipo descreve uma referência a um elemento.

Exemplo

// 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 o número de elementos.

Sintaxe

size_type size();

Comentários

A função membro retorna o comprimento da sequência controlada. Use para determinar o número de elementos que estão na sequência controlada no momento. Se sua preocupação é apenas se a sequência tem tamanho diferente de zero, confira priority_queue::empty (STL/CLR)().

Exemplo

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

O tipo de uma distância com sinal entre dois elementos.

Sintaxe

typedef int size_type;

Comentários

O tipo descreve uma contagem de elementos não negativos.

Exemplo

// 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 a sequência controlada para uma nova matriz.

Sintaxe

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

Comentários

A função membro retorna uma matriz que contém a sequência controlada. Use para obter uma cópia da sequência controlada em formato de matriz.

Exemplo

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

Acessa o elemento de prioridade mais alta.

Sintaxe

reference top();

Comentários

A função membro retorna uma referência para o elemento superior (de prioridade mais alta) da sequência controlada, que não pode ser vazio. Use-o para acessar o elemento de prioridade mais alta, quando souber que ele existe.

Exemplo

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

Acessa o elemento de prioridade mais alta.

Sintaxe

property value_type back_item;

Comentários

A propriedade acessa o elemento superior (de prioridade mais alta) da sequência controlada, que deve ser não vazio. Use-a para ler ou gravar o elemento de prioridade mais alta, quando souber que ele existe.

Exemplo

// 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 o delegado de ordenação para dois elementos.

Sintaxe

value_compare^ value_comp();

Comentários

A função membro retorna o delegado de ordenação usado para ordenar a sequência controlada. Use-o para comparar dois valores.

Exemplo

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

O delegado de ordenação para dois valores.

Sintaxe

binary_delegate<value_type, value_type, int> value_compare;

Comentários

O tipo é um sinônimo para o delegado que determina se o primeiro argumento é ordenado antes do segundo.

Exemplo

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

O tipo de um elemento.

Sintaxe

typedef Value value_type;

Comentários

O tipo é um sinônimo do parâmetro de modelo Value.

Exemplo

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