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
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de