`queue` (STL/CLR)

Artículo
04/22/2023

La clase de plantilla describe un objeto que controla una secuencia de longitud variable de elementos que tiene acceso primero en salir. Use el adaptador queue de contenedor para administrar un contenedor subyacente como una cola.

En la descripción siguiente, GValue es igual que Value a menos que este último sea un tipo ref, 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 queue
        :   public
        System::ICloneable,
        Microsoft::VisualC::StlClr::IQueue<GValue, GContainer>
    { ..... };

Parámetros

Value
Tipo de un elemento de la secuencia controlada.

Container
Tipo del contenedor subyacente.

Requisitos

Encabezado: <cliext/queue>

Espacio de nombres: cliext

Importante

Para compilar los ejemplos de este tema, asegúrese de que ha instalado compatibilidad con C++/CLI, tal como se describe en Instalación de la compatibilidad con C++/CLI en Visual Studio 2022. Para el tipo de proyecto, cree una aplicación de consola CLR (.NET Framework).

Declaraciones

Definición de tipo	Descripción
`queue::const_reference`	El tipo de una referencia constante a un elemento.
`queue::container_type`	Tipo del contenedor subyacente.
`queue::difference_type`	El tipo de una distancia con signo entre dos elementos.
`queue::generic_container`	Tipo de la interfaz genérica para el adaptador de contenedor.
`queue::generic_value`	Tipo de un elemento para la interfaz genérica del adaptador de contenedor.
`queue::reference`	El tipo de una referencia a un elemento.
`queue::size_type`	El tipo de una distancia con signo entre dos elementos.
`queue::value_type`	El tipo de un elemento.

Función de miembro	Descripción
`queue::assign`	Reemplaza todos los elementos.
`queue::back`	Obtiene acceso al último elemento.
`queue::empty`	Comprueba si no hay ningún elemento presente.
`queue::front`	Obtiene acceso al primer elemento.
`queue::get_container`	Accede al contenedor subyacente.
`queue::pop`	Quita el primer elemento.
`queue::push`	Agrega un nuevo último elemento.
`queue::queue`	Construye un objeto contenedor.
`queue::size`	Cuenta el número de elementos.
`queue::to_array`	Copia la secuencia controlada en una nueva matriz.

Propiedad	Descripción
`queue::back_item`	Obtiene acceso al último elemento.
`queue::front_item`	Obtiene acceso al primer elemento.

Operator	Descripción
`queue::operator=`	Reemplaza la secuencia controlada.
`operator!=` (cola)	Determina si un `queue` objeto no es igual a otro `queue` objeto.
`operator<` (cola)	Determina si un objeto `queue` es menor que otro objeto `queue`.
`operator<=` (cola)	Determina si un objeto `queue` es menor o igual que otro objeto `queue`.
`operator==` (cola)	Determina si un objeto `queue` es igual que otro objeto `queue`.
`operator>` (cola)	Determina si un objeto `queue` es mayor que otro objeto `queue`.
`operator>=` (cola)	Determina si un objeto `queue` es mayor o igual que otro objeto `queue`.

Interfaces

Interfaz	Descripción
ICloneable	Duplica un objeto.
`IQueue<Value, Container>`	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 Value elementos y crece a petición. El objeto restringe el acceso a simplemente insertar el primer elemento y extraer el último elemento, implementando una cola primero donde el primero en entrar es el primero en salir (también conocida como cola FIFO, por su acrónimo en inglés, o simplemente una cola).

Miembros

`queue::assign`

Reemplaza todos los elementos.

Sintaxis

void assign(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_queue_assign.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue c2;
    c2.assign(c1);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
a b c

`queue::back`

Obtiene acceso al último elemento.

Sintaxis

reference back();

Comentarios

La función miembro devuelve una referencia al último elemento de la secuencia controlada, que debe ser no vacía. Se usa para acceder al último elemento, cuando se sabe que existe uno.

Ejemplo

// cliext_queue_back.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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("back() = {0}", c1.back());

    // alter last item and reinspect
    c1.back() = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
back() = c
a b x

`queue::back_item`

Obtiene acceso al último elemento.

Sintaxis

property value_type back_item;

Comentarios

La propiedad tiene acceso al último elemento de la secuencia controlada, que debe ser no vacía. Se usa para leer o escribir el último elemento, cuando sepa que existe uno.

Ejemplo

// cliext_queue_back_item.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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("back_item = {0}", c1.back_item);

    // alter last item and reinspect
    c1.back_item = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
back_item = c
a b x

`queue::const_reference`

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_queue_const_reference.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents "a b c"
    for (; !c1.empty(); c1.pop())
        {   // get a const reference to an element
        Myqueue::const_reference cref = c1.front();
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
}

a b c

`queue::container_type`

Tipo del contenedor subyacente.

Sintaxis

typedef Container value_type;

Comentarios

El tipo es un sinónimo del parámetro de plantilla Container.

Ejemplo

// cliext_queue_container_type.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue c1;
    c1.push(L'a');
    c1.push(L'b');
    c1.push(L'c');

    // display contents "a b c" using container_type
    Myqueue::container_type wc1 = c1.get_container();
    for each (wchar_t elem in wc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c

`queue::difference_type`

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_queue_difference_type.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue::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);
}

a b c
pushing 2 = -2
popping 3 = 3

`queue::empty`

Comprueba si no hay ningún elemento presente.

Sintaxis

bool empty();

Comentarios

La función miembro devuelve true para una secuencia controlada vacía. Equivale a size() == 0. Se usa para comprobar si está queue vacío.

Ejemplo

// cliext_queue_empty.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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);
}

a b c
size() = 3
empty() = False
size() = 0
empty() = True

`queue::front`

Obtiene acceso al primer elemento.

Sintaxis

reference front();

Comentarios

La función miembro devuelve una referencia al primer elemento de la secuencia controlada, que no debe estar vacío. Se usa para acceder al primer elemento, cuando se sabe que existe uno.

Ejemplo

// cliext_queue_front.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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 first item
    System::Console::WriteLine("front() = {0}", c1.front());

    // alter first item and reinspect
    c1.front() = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
front() = a
x b c

`queue::front_item`

Obtiene acceso al primer elemento.

Sintaxis

property value_type front_item;

Comentarios

La propiedad tiene acceso al primer elemento de la secuencia controlada, que debe ser no vacía. Se usa para leer o escribir el primer elemento, cuando se sabe que existe uno.

Ejemplo

// cliext_queue_front_item.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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("front_item = {0}", c1.front_item);

    // alter last item and reinspect
    c1.front_item = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
front_item = a
x b c

`queue::generic_container`

Tipo de la interfaz genérica para el adaptador de contenedor.

Sintaxis

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

Comentarios

El tipo describe la interfaz genérica de la clase de este adaptador de contenedor de plantilla.

Ejemplo

// cliext_queue_generic_container.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue::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);
}

a b c
a b c
a b c d
a b c d e

`queue::generic_value`

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_queue_generic_value.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1->get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display in order using generic_value
    for (; !gc1->empty(); gc1->pop())
        {
        Myqueue::generic_value elem = gc1->front();

        System::Console::Write("{0} ", elem);
        }
    System::Console::WriteLine();
    return (0);
}

a b c
a b c
a b c

`queue::get_container`

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_queue_get_container.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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);
}

a b c

`queue::operator=`

Reemplaza la secuencia controlada.

Sintaxis

queue <Value, Container>% operator=(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 de right.

Ejemplo

// cliext_queue_operator_as.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue c2;
    c2 = c1;
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
a b c

`queue::pop`

Quita el primer elemento.

Sintaxis

void pop();

Comentarios

Quita el primer elemento de la secuencia controlada, que debe ser no vacía.

Ejemplo

// cliext_queue_pop.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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);
}

a b c
b c

`queue::push`

Agrega un nuevo último elemento.

Sintaxis

void push(value_type val);

Comentarios

La función miembro agrega un elemento con valor val al final de la cola. Se usa para anexar un elemento a la cola.

Ejemplo

// cliext_queue_push.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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);
}

a b c

`queue::queue`

Construye un objeto de adaptador contenedor.

Sintaxis

queue();
queue(queue<Value, Container>% right);
queue(queue<Value, Container>^ right);
explicit queue(container_type% wrapped);

Parámetros

right
Objeto que se va a copiar.

wrapped
Contenedor encapsulado que se va a usar.

Comentarios

El constructor:

queue();

crea un contenedor encapsulado vacío. Se usa para especificar una secuencia controlada inicial vacía.

El constructor:

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

crea un contenedor encapsulado que es una copia de right.get_container(). Se usa para especificar una secuencia controlada inicial que es una copia de la secuencia controlada por el queue objeto right.

El constructor:

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

crea un contenedor encapsulado que es una copia de right->get_container(). Se usa para especificar una secuencia controlada inicial que es una copia de la secuencia controlada por el queue objeto *right.

El constructor:

explicit queue(container_type wrapped);

usa el contenedor wrapped existente como contenedor encapsulado. Se usa para construir un queue objeto a partir de un contenedor existente.

Ejemplo

// cliext_queue_construct.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>
#include <cliext/list>

typedef cliext::queue<wchar_t> Myqueue;
typedef cliext::list<wchar_t> Mylist;
typedef cliext::queue<wchar_t, Mylist> Myqueue_list;
int main()
{
    // construct an empty container
    Myqueue c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    // construct from an underlying container
    Mylist v2(5, L'x');
    Myqueue_list c2(v2);
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    Myqueue_list c3(c2);
    for each (wchar_t elem in c3.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container through handle
    Myqueue_list c4(%c2);
    for each (wchar_t elem in c4.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

size() = 0
x x x x x
x x x x x
x x x x x

`queue::reference`

El tipo de una referencia a un elemento.

Sintaxis

typedef value_type% reference;

Comentarios

El tipo describe una referencia a un elemento.

Ejemplo

// cliext_queue_reference.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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 back of queue and redisplay
    Myqueue::reference ref = c1.back();
    ref = L'x';
    for each (wchar_t elem in c1.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
}

a b c
a b x

`queue::size`

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 todo lo que le interesa es si la secuencia tiene un tamaño distinto de cero, consulte empty().

Ejemplo

// cliext_queue_size.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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);
}

a b c
size() = 3 starting with 3
size() = 2 after popping
size() = 4 after adding 2

`queue::size_type`

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_queue_size_type.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue::size_type diff = c1.size();
    c1.pop();
    c1.pop();
    diff -= c1.size();
    System::Console::WriteLine("size difference = {0}", diff);
    return (0);
}

a b c
size difference = 2

`queue::to_array`

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_queue_to_array.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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);
}

a b c d
a b c

`queue::value_type`

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_queue_value_type.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
        Myqueue::value_type val = c1.front();

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
}

a b c

`operator!=` (cola)

Queue no es igual a la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator!=(queue<Value, Container>% left,
        queue<Value, Container>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve !(left == right). Se usa para probar si left no se ordena igual que right cuando las dos colas se comparan por elemento.

Ejemplo

// cliext_queue_operator_ne.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
}

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

`operator<` (cola)

Queue menor que la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator<(queue<Value, Container>% left,
        queue<Value, Container>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve true si, para la posición i más baja para la que !(right[i] < left[i]) también es true que left[i] < right[i]. De lo contrario, devuelve left->size() < right->size(). Se usa para probar si left se ordena antes right de que se comparen las dos colas por elemento.

Ejemplo

// cliext_queue_operator_lt.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
}

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

`operator<=` (cola)

Queue menor o igual que la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator<=(queue<Value, Container>% left,
        queue<Value, Container>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve !(right < left). Se usa para probar si left no se ordena después right de que las dos colas se comparen por elemento.

Ejemplo

// cliext_queue_operator_le.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

/    / display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
}

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

`operator==` (cola)

Queue igual comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator==(queue<Value, Container>% left,
        queue<Value, Container>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve true solo si las secuencias controladas por left y right tienen la misma longitud y, para cada posición i, left[i] == right[i]. Se usa para probar si left se ordena igual que right cuando las dos colas se comparan por elemento.

Ejemplo

// cliext_queue_operator_eq.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
}

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

`operator>` (cola)

Queue mayor que la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator>(queue<Value, Container>% left,
        queue<Value, Container>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve right < left. Se usa para probar si left se ordena después right de cuando las dos colas se comparan elemento por elemento.

Ejemplo

// cliext_queue_operator_gt.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
}

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

`operator>=` (cola)

Queue mayor o igual que la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator>=(queue<Value, Container>% left,
        queue<Value, Container>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve !(left < right). Se usa para probar si left no se ordena antes right de que se comparen las dos colas por elemento.

Ejemplo

// cliext_queue_operator_ge.cpp
// compile with: /clr
#include "pch.h"
#include <cliext/queue>

typedef cliext::queue<wchar_t> Myqueue;
int main()
{
    Myqueue 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
    Myqueue c2;
    c2.push(L'a');
    c2.push(L'b');
    c2.push(L'd');

    // display contents "a b d"
    for each (wchar_t elem in c2.get_container())
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
}

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False

Compartir a través de

queue (STL/CLR)

Sintaxis

Parámetros

Requisitos

Declaraciones

Interfaces

Comentarios

Miembros

queue::assign

Sintaxis

Parámetros

Comentarios

Ejemplo

queue::back

Sintaxis

Comentarios

Ejemplo

queue::back_item

Sintaxis

Comentarios

Ejemplo

queue::const_reference

Sintaxis

Comentarios

Ejemplo

queue::container_type

Sintaxis

Comentarios

Ejemplo

queue::difference_type

Sintaxis

Comentarios

Ejemplo

queue::empty

Sintaxis

Comentarios

Ejemplo

queue::front

Sintaxis

Comentarios

Ejemplo

queue::front_item

Sintaxis

Comentarios

Ejemplo

queue::generic_container

Sintaxis

Comentarios

Ejemplo

queue::generic_value

Sintaxis

Comentarios

Ejemplo

queue::get_container

Sintaxis

Comentarios

Ejemplo

queue::operator=

Sintaxis

Parámetros

Comentarios

Ejemplo

queue::pop

Sintaxis

Comentarios

Ejemplo

queue::push

Sintaxis

Comentarios

Ejemplo

queue::queue

Sintaxis

Parámetros

Comentarios

Ejemplo

queue::reference

Sintaxis

Comentarios

Ejemplo

`queue` (STL/CLR)

`queue::assign`

`queue::back`

`queue::back_item`

`queue::const_reference`

`queue::container_type`

`queue::difference_type`

`queue::empty`

`queue::front`

`queue::front_item`

`queue::generic_container`

`queue::generic_value`

`queue::get_container`

`queue::operator=`

`queue::pop`

`queue::push`

`queue::queue`

`queue::reference`

`queue::size`

`queue::size_type`

`queue::to_array`

`queue::value_type`

`operator!=` (cola)

`operator<` (cola)

`operator<=` (cola)

`operator==` (cola)

`operator>` (cola)

`operator>=` (cola)