EVAP2

<Stack>

Encabezado que define la pila clase de contenedor:

Clases

pila   -------   Pila LIFO (plantilla de clase)

Las pilas son un tipo de adaptador de recipiente, específicamente diseñado para operar en un contexto LIFO (último en entrar, primero en salir), donde se insertan elementos y extrajeron sólo desde un extremo del recipiente. apile s se implementan como contenedores adaptadores , que son las clases que utilizan un objeto encapsulado de una clase contenedor específico como su contenedor subyacente , proporcionando un conjunto específico de funciones miembro para acceder a sus elementos. Los elementos se empujan / aparecido desde el "back" del contenedor específico, que se conoce como la parte superior de la pila. El contenedor subyacente puede ser cualquiera de las plantillas de clase contenedor estándar o alguna otra clase de contenedor diseñado específicamente. Los recipientes deberán soportar las siguientes operaciones:

-vacío

-tamaño

-espalda

-push_back

-pop_back

Las clases de contenedores estándar vector, deque y listacumplir con estos requisitos. Por defecto, si no se especifica ninguna clase de contenedor para un particular,pila clase de instancias, el contenedor estándar deque se utiliza.

ejemplo en c++

1)

// constructing stacks
#include <iostream>       // std::cout
#include <stack>          // std::stack
#include <vector>         // std::vector
#include <deque>          // std::deque

int main ()
{
  std::deque<int> mydeque (3,100);          // deque with 3 elements
  std::vector<int> myvector (2,200);        // vector with 2 elements

  std::stack<int> first;                    // empty stack
  std::stack<int> second (mydeque);         // stack initialized to copy of deque

  std::stack<int,std::vector<int> > third;  // empty stack using vector
  std::stack<int,std::vector<int> > fourth (myvector);

  std::cout << "size of first: " << first.size() << '\n';
  std::cout << "size of second: " << second.size() << '\n';
  std::cout << "size of third: " << third.size() << '\n';
  std::cout << "size of fourth: " << fourth.size() << '\n';

  return 0;
}

2)

// swap stacks
#include <iostream>       // std::cout
#include <Stack>          // std::stack, std::swap(stack)

int main ()
{
  std::stack<int> foo,bar;
  foo.push (10); foo.push(20); foo.push(30);
  bar.push (111); bar.push(222);

  swap(foo,bar);

  std::cout << "size of foo: " << foo.size() << '\n';
  std::cout << "size of bar: " << bar.size() << '\n';

  return 0;
}

3)

template <class T, class Container, class Alloc>
  struct uses_allocator<stack<T,Container>,Alloc>
    : uses_allocator<Container,Alloc>::type {}