`stack` (STL/CLR)

Artículo
04/03/2023

La clase de plantilla describe un objeto que controla una secuencia de longitud variable de elementos que tienen un acceso donde el último en entrar es el primero en salir. El adaptador de contenedor stack se usa para administrar un contenedor subyacente como una pila de inserción.

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 stack
        :   public
        System::ICloneable,
        Microsoft::VisualC::StlClr::IStack<GValue, GContainer>
    { ..... };

Parámetros

Value
Tipo de un elemento de la secuencia controlada.

Container
Tipo del contenedor subyacente.

Requisitos

Encabezado:<cliext/stack>

Espacio de nombres: cliext

Declaraciones

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

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

Propiedad	Descripción
`stack::top_item`	Obtiene acceso al último elemento.

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

Interfaces

Interfaz	Descripción
ICloneable	Duplica un objeto.
`IStack<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 insertar y extraer solo el último elemento, implementando una cola donde el último en entrar es el primero en salir (también conocida como cola o pila LIFO, por su acrónimo en inglés).

Miembros

`stack::assign`

Reemplaza todos los elementos.

Sintaxis

void assign(stack<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 pila.

Ejemplo

// cliext_stack_assign.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack 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

`stack::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_stack_const_reference.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
        Mystack::const_reference cref = c1.top();
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

c b a

`stack::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_stack_container_type.cpp
// compile with: /clr
#include <cliext/stack>

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

// display contents " a b c" using container_type
    Mystack::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

`stack::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_stack_difference_type.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack::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

`stack::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á stack vacío.

Ejemplo

// cliext_stack_empty.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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

`stack::generic_container`

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

Sintaxis

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

Comentarios

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

Ejemplo

// cliext_stack_generic_container.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack::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

`stack::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_stack_generic_value.cpp
// compile with: /clr
#include <cliext/stack>

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

// display in reverse using generic_value
    for (; !gc1->empty(); gc1->pop())
        {
        Mystack::generic_value elem = gc1->top();

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

a b c
a b c
c b a

`stack::get_container`

Accede al contenedor subyacente.

Sintaxis

container_type^ get_container();

Comentarios

La función miembro devuelve un identificador para el contenedor subyacente. Se usa para omitir las restricciones impuestas por el contenedor.

Ejemplo

// cliext_stack_get_container.cpp
// compile with: /clr
#include <cliext/stack>

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

// display contents " a b c" using container_type
    Mystack::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

`stack::operator=`

Reemplaza la secuencia controlada.

Sintaxis

stack<Value, Container>% operator=(stack<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_stack_operator_as.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack 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

`stack::pop`

Quita el último elemento.

Sintaxis

void pop();

Comentarios

La función miembro elimina el último elemento de la secuencia controlada, que no debe estar vacío. Se usa para acortar por stack un elemento en la parte posterior.

Ejemplo

// cliext_stack_pop.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
a b

`stack::push`

Agrega un nuevo último elemento.

Sintaxis

void push(value_type val);

Comentarios

La función miembro inserta un elemento con valor val al final de la secuencia controlada. Se usa para anexar otro elemento a la pila.

Ejemplo

// cliext_stack_push.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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

`stack::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_stack_reference.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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 stack and redisplay
    Mystack::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);
    }

a b c
a b x

`stack::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 stack::empty.

Ejemplo

// cliext_stack_size.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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

`stack::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_stack_size_type.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack::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

`stack::stack`

Construye un objeto de adaptador contenedor.

Sintaxis

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

Parámetros

right
Objeto que se va a copiar.

wrapped
Contenedor encapsulado que se va a usar.

Comentarios

El constructor:

stack();

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

El constructor:

stack(stack<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 stack objeto right.

El constructor:

stack(stack<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 stack objeto *right.

El constructor:

explicit stack(container_type% wrapped);

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

Ejemplo

// cliext_stack_construct.cpp
// compile with: /clr
#include <cliext/stack>
#include <cliext/vector>

typedef cliext::stack<wchar_t> Mystack;
typedef cliext::vector<wchar_t> Myvector;
typedef cliext::stack<wchar_t, Myvector> Mystack_vec;
int main()
    {
// construct an empty container
    Mystack c1;
    System::Console::WriteLine("size() = {0}", c1.size());

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

// construct by copying another container
    Mystack_vec 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
    Mystack_vec 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

`stack::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_stack_to_array.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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

`stack::top`

Obtiene acceso al último elemento.

Sintaxis

reference top();

Comentarios

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

Ejemplo

// cliext_stack_top.cpp
// compile with: /clr
#include <cliext/stack>

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

a b c
top() = c
a b x

`stack::top_item`

Obtiene acceso al último elemento.

Sintaxis

property value_type top_item;

Comentarios

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

Ejemplo

// cliext_stack_top_item.cpp
// compile with: /clr
#include <cliext/stack>

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

a b c
top_item = c
a b x

`stack::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_stack_value_type.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
        Mystack::value_type val = c1.top();

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

c b a

`operator!=` (pila)

Stack no es igual a la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator!=(stack<Value, Container>% left,
        stack<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 pilas se comparan elemento por elemento.

Ejemplo

// cliext_stack_operator_ne.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack 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<` (pila)

Stack menor que la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator<(stack<Value, Container>% left,
        stack<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 pilas por elemento.

Ejemplo

// cliext_stack_operator_lt.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack 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<=` (pila)

Stack menor o igual que la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator<=(stack<Value, Container>% left,
        stack<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 pilas se comparen por elemento.

Ejemplo

// cliext_stack_operator_le.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack 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==` (pila)

Stack igual comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator==(stack<Value, Container>% left,
        stack<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 pilas se comparan por elemento.

Ejemplo

// cliext_stack_operator_eq.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack 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>` (pila)

Stack mayor que la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator>(stack<Value, Container>% left,
        stack<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 cuándo se comparan las dos pilas elemento por elemento.

Ejemplo

// cliext_stack_operator_gt.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack 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>=` (pila)

Stack mayor o igual que la comparación.

Sintaxis

template<typename Value,
    typename Container>
    bool operator>=(stack<Value, Container>% left,
        stack<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 pilas por elemento.

Ejemplo

// cliext_stack_operator_ge.cpp
// compile with: /clr
#include <cliext/stack>

typedef cliext::stack<wchar_t> Mystack;
int main()
    {
    Mystack 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
    Mystack 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

stack (STL/CLR)

Sintaxis

Parámetros

Requisitos

Declaraciones

Interfaces

Comentarios

Miembros

stack::assign

Sintaxis

Parámetros

Comentarios

Ejemplo

stack::const_reference

Sintaxis

Comentarios

Ejemplo

stack::container_type

Sintaxis

Comentarios

Ejemplo

stack::difference_type

Sintaxis

Comentarios

Ejemplo

stack::empty

Sintaxis

Comentarios

Ejemplo

stack::generic_container

Sintaxis

Comentarios

Ejemplo

stack::generic_value

Sintaxis

Comentarios

Ejemplo

stack::get_container

Sintaxis

Comentarios

Ejemplo

stack::operator=

Sintaxis

Parámetros

Comentarios

Ejemplo

stack::pop

Sintaxis

Comentarios

Ejemplo

stack::push

Sintaxis

Comentarios

Ejemplo

stack::reference

Sintaxis

Comentarios

Ejemplo

stack::size

Sintaxis

Comentarios

Ejemplo

stack::size_type

Sintaxis

Comentarios

Ejemplo

stack::stack

Sintaxis

Parámetros

Comentarios

Ejemplo

stack::to_array

Sintaxis

Comentarios

Ejemplo

stack::top

Sintaxis

Comentarios

Ejemplo

`stack` (STL/CLR)

`stack::assign`

`stack::const_reference`

`stack::container_type`

`stack::difference_type`

`stack::empty`

`stack::generic_container`

`stack::generic_value`

`stack::get_container`

`stack::operator=`

`stack::pop`

`stack::push`

`stack::reference`

`stack::size`

`stack::size_type`

`stack::stack`

`stack::to_array`

`stack::top`

`stack::top_item`

`stack::value_type`

`operator!=` (pila)

`operator<` (pila)

`operator<=` (pila)

`operator==` (pila)

`operator>` (pila)

`operator>=` (pila)