priority_queue (STL/CLR)
La clase de plantilla describe un objeto que controla una secuencia ordenada de elementos de longitud variable que tiene acceso limitado. Para administrar un contenedor subyacente como una cola, se usa el adaptador de contenedor priority_queue.
En la descripción siguiente, GValue es igual que Value, a menos que este último sea un tipo de referencia, en cuyo caso es Value^. De forma similar, GContainer es igual que Container, a menos que este último sea un tipo ref, en cuyo caso es Container^.
Sintaxis
template<typename Value,
typename Container>
ref class priority_queue
System::ICloneable,
Microsoft::VisualC::StlClr::IPriorityQueue<GValue, GContainer>
{ ..... };
Parámetros
Valor
Tipo de un elemento de la secuencia controlada.
Contenedor
Tipo del contenedor subyacente.
Requisitos
Encabezado:<cliext/queue>
Espacio de nombres: cliext
Declaraciones
| Definición de tipo | Descripción |
|---|---|
| priority_queue::const_reference (STL/CLR) | El tipo de una referencia constante a un elemento. |
| priority_queue::container_type (STL/CLR) | Tipo del contenedor subyacente. |
| priority_queue::difference_type (STL/CLR) | El tipo de una distancia con signo entre dos elementos. |
| priority_queue::generic_container (STL/CLR) | Tipo de la interfaz genérica para el adaptador de contenedor. |
| priority_queue::generic_value (STL/CLR) | Tipo de un elemento para la interfaz genérica del adaptador de contenedor. |
| priority_queue::reference (STL/CLR) | El tipo de una referencia a un elemento. |
| priority_queue::size_type (STL/CLR) | El tipo de una distancia con signo entre dos elementos. |
| priority_queue::value_compare (STL/CLR) | Delegado de ordenación de dos elementos. |
| priority_queue::value_type (STL/CLR) | El tipo de un elemento. |
| Función miembro | Descripción |
|---|---|
| priority_queue::assign (STL/CLR) | Reemplaza todos los elementos. |
| priority_queue::empty (STL/CLR) | Comprueba si no hay ningún elemento presente. |
| priority_queue::get_container (STL/CLR) | Accede al contenedor subyacente. |
| priority_queue::pop (STL/CLR) | Quita el elemento con la prioridad más alta. |
| priority_queue::priority_queue (STL/CLR) | Construye un objeto contenedor. |
| priority_queue::push (STL/CLR) | Agrega un nuevo elemento. |
| priority_queue::size (STL/CLR) | Cuenta el número de elementos. |
| priority_queue::top (STL/CLR) | Accede al elemento con la prioridad más alta. |
| priority_queue::to_array (STL/CLR) | Copia la secuencia controlada en una nueva matriz. |
| priority_queue::value_comp (STL/CLR) | Copia el delegado de ordenación para dos elementos. |
| Propiedad | Descripción |
|---|---|
| priority_queue::top_item (STL/CLR) | Accede al elemento con la prioridad más alta. |
| Operator | Descripción |
|---|---|
| priority_queue::operator= (STL/CLR) | Reemplaza la secuencia controlada. |
Interfaces
| Interfaz | Descripción |
|---|---|
| ICloneable | Duplica un objeto. |
| IPriorityQueue<Valor, Contenedor> | Mantenga el adaptador de contenedor genérico. |
Comentarios
El objeto asigna y libera almacenamiento para la secuencia que controla a través de un contenedor subyacente, de tipo Container, que almacena elementos Value y aumenta a petición. Mantiene la secuencia ordenada como un montón, con el elemento de prioridad más alta (elemento superior) fácilmente accesible y extraíble. El objeto restringe el acceso a insertar nuevos elementos y sacar solo el elemento de prioridad más alta, lo que implementa una cola de prioridad.
El objeto ordena la secuencia que controla mediante una llamada a un objeto delegado almacenado del tipo priority_queue::value_compare (STL/CLR). Puede especificar el objeto delegado almacenado al construir el objeto priority_queue; si no especifica ningún objeto delegado, el valor predeterminado es la comparación operator<(value_type, value_type). Para acceder a este objeto almacenado, llame a la función miembro priority_queue::value_comp (STL/CLR)().
Este objeto delegado debe imponer un orden débil estricto en los valores de tipo priority_queue::value_type (STL/CLR). Esto significa que, para dos claves X y Y:
value_comp()(X, Y) devuelve el mismo resultado booleano en cada llamada.
Si value_comp()(X, Y) es true, value_comp()(Y, X) debe ser false.
Si value_comp()(X, Y) es true, se dice que X se ordena antes de Y.
Si !value_comp()(X, Y) && !value_comp()(Y, X) es true, X e Y tienen una ordenación equivalente.
En cualquier elemento X que preceda a Y en la secuencia controlada, key_comp()(Y, X) es false. Para el objeto delegado predeterminado, nunca disminuye el valor de las claves.
Por tanto, el elemento de prioridad más alta es uno de los elementos que no se ordenan delante de ningún otro elemento.
Puesto que el contenedor subyacente mantiene los elementos ordenados como un montón:
El contenedor debe admitir iteradores de acceso aleatorio.
Los elementos con ordenación equivalente se pueden sacar en un orden diferente al que se insertaron. La ordenación no es estable.
Por tanto, los candidatos para el contenedor subyacente son deque (STL/CLR) y vector (STL/CLR).
Miembros
priority_queue::assign (STL/CLR)
Reemplaza todos los elementos.
Sintaxis
void assign(priority_queue<Value, Container>% right);
Parámetros
right
Adaptador de contenedor que se va a insertar.
Comentarios
La función miembro asigna right.get_container() al contenedor subyacente. Se usa para cambiar todo el contenido de la cola.
Ejemplo
// 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)
El tipo de una referencia constante a un elemento.
Sintaxis
typedef value_type% const_reference;
Comentarios
El tipo describe una referencia constante a un elemento.
Ejemplo
// 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 contenedor subyacente.
Sintaxis
typedef Container value_type;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Container.
Ejemplo
// 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)
Tipos de una distancia con signo entre dos elementos.
Sintaxis
typedef int difference_type;
Comentarios
El tipo describe un recuento de elementos posiblemente negativo.
Ejemplo
// 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)
Comprueba si no hay ningún elemento presente.
Sintaxis
bool empty();
Comentarios
La función miembro devuelve true para una secuencia controlada vacía. Es equivalente a priority_queue::size (STL/CLR)() == 0. Se usa para comprobar si la cola de prioridad está vacía.
Ejemplo
// 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 de la interfaz genérica para el contenedor.
Sintaxis
typedef Microsoft::VisualC::StlClr::IPriorityQueue<Value>
generic_container;
Comentarios
El tipo describe la interfaz genérica de la clase de este adaptador de contenedor de plantilla.
Ejemplo
// 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 de elemento para usarlo con la interfaz genérica del contenedor.
Sintaxis
typedef GValue generic_value;
Comentarios
El tipo describe un objeto de tipo GValue que describe el valor del elemento almacenado que se debe usar con la interfaz genérica de esta clase contenedora de plantilla. GValue es value_type o value_type^ si value_type es un tipo ref.
Ejemplo
// 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 contenedor subyacente.
Sintaxis
container_type get_container();
Comentarios
La función miembro devuelve el contenedor subyacente. Se usa para omitir las restricciones impuestas por el contenedor.
Ejemplo
// 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)
Reemplaza la secuencia controlada.
Sintaxis
priority_queue <Value, Container>% operator=(priority_queue <Value, Container>% right);
Parámetros
right
Adaptador de contenedor que se va a copiar.
Comentarios
El operador miembro copia right en el objeto y, a continuación, devuelve *this. Se usa para reemplazar la secuencia controlada por una copia de la secuencia controlada del elemento right.
Ejemplo
// 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)
Quita el elemento con la prioridad más alta.
Sintaxis
void pop();
Comentarios
La función miembro quita el elemento con la prioridad más alta de la secuencia controlada, que no debe estar vacía. Se usa para acortar la cola en un elemento en la parte posterior.
Ejemplo
// 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)
Construye un objeto de adaptador contenedor.
Sintaxis
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
Contenedor que se va a copiar.
first
Principio del intervalo que se va a insertar.
last
Fin del intervalo que se va a insertar.
pred
Predicado de ordenación de la secuencia controlada.
right
Objeto o intervalo que se va a insertar.
Comentarios
El constructor:
priority_queue();
crea un contenedor encapsulado vacío, con el predicado de ordenación predeterminado. Se usa para especificar una secuencia controlada inicial vacía, con el predicado de ordenación predeterminado.
El constructor:
priority_queue(priority_queue<Value, Container>% right);
crea un contenedor encapsulado que es una copia de right.get_container(), con el predicado de ordenación right.value_comp(). Se usa para especificar una secuencia controlada inicial que es una copia de la secuencia controlada por el objeto de cola right con el mismo predicado de ordenación.
El constructor:
priority_queue(priority_queue<Value, Container>^ right);
crea un contenedor encapsulado que es una copia de right->get_container(), con el predicado de ordenación right->value_comp(). Se usa para especificar una secuencia controlada inicial que es una copia de la secuencia controlada por el objeto de cola *right con el mismo predicado de ordenación.
El constructor:
explicit priority_queue(value_compare^ pred);
crea un contenedor encapsulado vacío, con el predicado de ordenación pred. Se usa para especificar una secuencia controlada inicial vacía, con el predicado de ordenación especificado.
El constructor:
priority_queue(value_compare^ pred, container_type cont);
crea un contenedor encapsulado vacío, con el predicado de ordenación pred y, a continuación, inserta todos los elementos de cont. Se usa para especificar una secuencia controlada inicial de un contenedor que ya existe, con el predicado de ordenación especificado.
El constructor:
template<typename InIt> priority_queue(InIt first, InIt last);
crea un contenedor encapsulado vacío, con el predicado de ordenación predeterminado, y después inserta la secuencia [first, last). Se usa para especificar una secuencia controlada inicial a partir de una secuencia especificada, con el predicado de ordenación especificado.
El constructor:
template<typename InIt> priority_queue(InIt first, InIt last, value_compare^ pred);
crea un contenedor encapsulado vacío, con el predicado de ordenación pred, y después inserta la secuencia [first, last). Se usa para especificar una secuencia controlada inicial de una secuencia especificada, con el predicado de ordenación especificado.
El constructor:
template<typename InIt> priority_queue(InIt first, InIt last, value_compare^ pred, container_type% cont);
crea un contenedor encapsulado vacío, con el predicado de ordenación pred, y después inserta todos los elementos de cont más la secuencia [first, last). Se usa para especificar una secuencia controlada inicial de un contenedor que ya existe y una secuencia especificada, con el predicado de ordenación especificado.
Ejemplo
// 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)
Agrega un nuevo elemento.
Sintaxis
void push(value_type val);
Comentarios
La función miembro inserta un elemento con el valor val en la secuencia controlada y reordena la secuencia controlada para mantener la disciplina de montón. Se usa para agregar otro elemento a la cola.
Ejemplo
// 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)
El tipo de una referencia a un elemento.
Sintaxis
typedef value_type% reference;
Comentarios
El tipo describe una referencia a un elemento.
Ejemplo
// 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)
Cuenta el número de elementos.
Sintaxis
size_type size();
Comentarios
La función miembro devuelve la longitud de la secuencia controlada. Se usa para determinar el número de elementos que están actualmente en la secuencia controlada. Si lo único que le interesa es si la secuencia tiene un tamaño distinto de cero, consulte priority_queue::empty (STL/CLR)().
Ejemplo
// 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)
El tipo de una distancia con signo entre dos elementos.
Sintaxis
typedef int size_type;
Comentarios
El tipo describe un recuento de elementos no negativo.
Ejemplo
// 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 secuencia controlada en una nueva matriz.
Sintaxis
cli::array<Value>^ to_array();
Comentarios
La función miembro devuelve una matriz que contiene la secuencia controlada. Se usa para obtener una copia de la secuencia controlada en forma de matriz.
Ejemplo
// 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 al elemento con la prioridad más alta.
Sintaxis
reference top();
Comentarios
La función miembro devuelve una referencia al primer elemento de la secuencia controlada, que no debe estar vacía. Se usa para acceder al elemento con la prioridad más alta, cuando se sabe que existe.
Ejemplo
// 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 al elemento con la prioridad más alta.
Sintaxis
property value_type back_item;
Comentarios
La propiedad accede al elemento superior (con la prioridad más alta) de la secuencia controlada, que no debe estar vacía. Se usa para leer o escribir el elemento con la prioridad más alta, cuando se sabe que existe.
Ejemplo
// 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 el delegado de ordenación para dos elementos.
Sintaxis
value_compare^ value_comp();
Comentarios
La función miembro devuelve el delegado de ordenación que se usa para ordenar la secuencia controlada. Se usa para comparar dos valores.
Ejemplo
// 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)
Delegado de ordenación para dos valores.
Sintaxis
binary_delegate<value_type, value_type, int> value_compare;
Comentarios
El tipo es un sinónimo del delegado que determina si el primer argumento se ordena delante del segundo.
Ejemplo
// 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)
El tipo de un elemento.
Sintaxis
typedef Value value_type;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Value.
Ejemplo
// 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
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de