priority_queue (STL/CLR)

La clase de plantilla describe un objeto que controla una secuencia ordenada de longitud variable de elementos que tiene acceso limitado. El adaptador de contenedor se usa priority_queue para administrar un contenedor subyacente como cola de prioridad.

En la descripción siguiente, es GValue igual que Value a menos que el último sea un tipo ref, en cuyo caso es Value^. Del mismo modo, 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

Rúbrica:< 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 para el 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 para 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)	Tiene acceso al contenedor subyacente.
priority_queue::pop (STL/CLR)	Quita el elemento de 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 de 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 de dos elementos.

Propiedad	Descripción
priority_queue::top_item (STL/CLR)	Accede al elemento de prioridad más alta.

Operador	Descripción
priority_queue::operator= (STL/CLR)	Reemplaza la secuencia controlada.

Interfaces

Interfaz	Descripción
ICloneable	Duplique un objeto .
IPriorityQueueValue<, 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, Containerde tipo , Value que almacena elementos y crece a petición. Mantiene la secuencia ordenada como un montón, con el elemento de prioridad más alta (el 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, implementando una cola de prioridad.

El objeto ordena la secuencia que controla mediante una llamada a un objeto delegado almacenado de tipo priority_queue::value_compare (STL/CLR). Puede especificar el objeto delegado almacenado al construir el 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 tipo de objeto delegado debe imponer una ordenación débil estricta en los valores de tipo priority_queue::value_type (STL/CLR). Es decir, para dos claves cualquiera y XY:

value_comp()(X, Y) devuelve el mismo resultado booleano en cada llamada.

Si value_comp()(X, Y) es true, debe value_comp()(Y, X) ser false.

Si value_comp()(X, Y) es true, se dice X que se ordena antes de Y.

Si !value_comp()(X, Y) && !value_comp()(Y, X) es true, se dice X que y Y tienen una ordenación equivalente.

Para cualquier elemento X que precede en Y la secuencia controlada, key_comp()(Y, X) es false. (Para el objeto delegado predeterminado, las claves nunca disminuyen en valor).

El elemento de prioridad más alta es, por tanto, uno de los elementos que no se ordena antes que 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 una ordenación equivalente se pueden sacar en un orden diferente al que se insertaron. (La ordenación no es estable).

Por lo tanto, los candidatos para el contenedor subyacente incluyen 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 insertará.

Comentarios

La función miembro asigna al right.get_container() 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 firma 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 probar si el priority_queue está vacío.

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 para esta clase de adaptador de contenedor de plantillas.

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 un elemento para su uso con la interfaz genérica para el contenedor.

Sintaxis

typedef GValue generic_value;

Comentarios

El tipo describe un objeto de tipo GValue que describe el valor del elemento almacenado para su uso con la interfaz genérica para esta clase contenedora de plantillas. (GValue es o value_type si value_type^ es value_type 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)

Tiene acceso 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 de contenedores.

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 copiará.

Comentarios

El operador miembro copia directamente en el objeto y, a continuación, devuelve *this. Se usa para reemplazar la secuencia controlada por una copia de la secuencia controlada a la derecha.

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 de mayor proiridad.

Sintaxis

void pop();

Comentarios

La función miembro quita el elemento de prioridad más alta de la secuencia controlada, que no debe estar vacío. 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 de 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
Final del intervalo que se va a insertar.

Pred
Predicado de ordenación para la secuencia controlada.

right
Objeto o intervalo que se va a insertar.

Comentarios

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.

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 derecho de objeto de cola, con el mismo predicado de ordenación.

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 *rightcola , con el mismo predicado de ordenación.

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.

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 existente, con el predicado de ordenación especificado.

Constructor:

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

crea un contenedor encapsulado vacío, con el predicado de ordenación predeterminado y, a continuación, inserta la secuencia [first, last). Se usa para especificar una secuencia controlada inicial a partir de una eqeuence especificada, con el predicado de ordenación especificado.

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, a continuación, inserta la secuencia [first, last). Se usa para especificar una secuencia controlada inicial a partir de una seqeuence especificada, con el predicado de ordenación especificado.

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, a continuación, inserta todos los elementos de cont más la secuencia [first, last). Se usa para especificar una secuencia controlada inicial de un contenedor existente y una seqeuence 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 valor val en la secuencia controlada y reordena la secuencia controlada para mantener la materia 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 hay actualmente en la secuencia controlada. Si lo único que le interesa es si la secuencia tiene un tamaño distinto de cero, vea 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)

Tipo de una distancia con firma entre dos elementos.

Sintaxis

typedef int size_type;

Comentarios

El tipo describe un recuento de elementos no negativos.

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 de prioridad más alta.

Sintaxis

reference top();

Comentarios

La función miembro devuelve una referencia al elemento superior (prioridad más alta) de la secuencia controlada, que debe no estar vacío. Se usa para acceder al elemento de prioridad más alta, cuando sepa 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 de prioridad más alta.

Sintaxis

property value_type back_item;

Comentarios

La propiedad tiene acceso al elemento superior (prioridad más alta) de la secuencia controlada, que no debe estar vacío. Se usa para leer o escribir el elemento de prioridad más alta, cuando sepa 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 de dos elementos.

Sintaxis

value_compare^ value_comp();

Comentarios

La función miembro devuelve el delegado de ordenación utilizado 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 antes que el 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