Classe stack

Uma classe do adaptador de contêiner de modelo que fornece uma restrição de funcionalidade que limita o acesso ao elemento mais recentemente adicionado a alguns tipos de contêiner subjacentes. A classe stack é usada quando é importante esclarecer que apenas as operações stack estão sendo executadas no contêiner.

Sintaxe

template <class Type, class Container= deque <Type>>
class stack

Parâmetros

Type
O tipo de dados do elemento a ser armazenado na stack.

Container
O tipo do contêiner subjacente usado para implementar a stack. O valor padrão é a classe deque<Type>.

Comentários

Os elementos da classe Type estipulados no primeiro parâmetro de modelo de um objeto de pilha são sinônimo de value_type e devem corresponder ao tipo de elemento na classe de contêiner subjacente Container estipulada pelo segundo parâmetro de modelo. O Type deve ser atribuível, para que seja possível copiar objetos desse tipo e atribuir valores a variáveis desse tipo.

As classes de contêiner subjacente adequadas para a pilha incluem as classes deque, list e vector ou qualquer outro contêiner de sequência que dê suporte às operações de back, push_back e pop_back. A classe de contêiner subjacente é encapsulada dentro do adaptador do contêiner, que expõe apenas o conjunto limitado de funções membro de contêiner de sequência como uma interface pública.

A igualdade dos objetos de stack será comparável somente se a igualdade dos elementos da classe Type for comparável, e serão comparáveis em menor-que somente se os elementos da classe Type forem comparáveis em menor-que.

• A classe stack dá suporte a uma estrutura de dados UEPS (último a entrar, primeiro a sair). Uma boa comparação é pensar em uma pilha de pratos. Os elementos (os pratos) podem inseridos, inspecionados ou removidos somente da parte superior da pilha, que é o último elemento no final do contêiner base. A restrição para acessar apenas o elemento superior é o motivo para usar a classe stack.

• A classe queue dá suporte a uma estrutura de dados PEPS (primeiro a entrar, primeiro a sair). Uma boa comparação é pensar em uma fila de banco. Os elementos (as pessoas) vão sendo adicionados na parte final da fila e são removidos do início dela. Tanto o início quanto o final da fila podem ser inspecionados. A restrição de acessar apenas os elementos inicial e final dessa maneira é o motivo para usar a classe queue.

• A classe priority_queue ordena seus elementos para que o elemento maior sempre esteja na posição superior. Ele dá suporte à inserção de um elemento e a inspeção e remoção do elemento superior. Uma boa comparação é pensar em pessoas em fila organizadas por idade, altura ou algum outro critério.

Membros

Construtores

Typedefs

Funções

container_type

Um tipo que fornece o contêiner base a ser adaptado.

typedef Container container_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloContainer. As três classes de contêiner da sequência da Biblioteca Padrão C++, vector, list e a classe deque padrão, atendem aos requisitos para serem usadas como o contêiner base para um objeto stack. Tipos definidos pelo usuário que satisfazem esses requisitos também podem ser usados.

Para obter mais informações sobre Container, consulte a seção Comentários do tópico stackClasse .

Exemplo

Veja o exemplo de stack::stack que demonstra como declarar e usar container_type.

empty

Testa se uma stack está vazia.

bool empty() const;

Valor de retorno

true se a pilha estiver vazia; false se a pilha não estiver vazia.

Exemplo

// stack_empty.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   // Declares stacks with default deque base container
   stack <int> s1, s2;

   s1.push( 1 );

   if ( s1.empty( ) )
      cout << "The stack s1 is empty." << endl;
   else
      cout << "The stack s1 is not empty." << endl;

   if ( s2.empty( ) )
      cout << "The stack s2 is empty." << endl;
   else
      cout << "The stack s2 is not empty." << endl;
}

The stack s1 is not empty.
The stack s2 is empty.

pop

Remove o elemento da parte superior da stack.

void pop();

Comentários

A stack não pode estar vazia para que seja possível aplicar a função membro. O início da stack é a posição ocupada pelo elemento adicionado mais recentemente e é o último elemento no fim do contêiner.

Exemplo

// stack_pop.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   stack <int> s1, s2;

   s1.push( 10 );
   s1.push( 20 );
   s1.push( 30 );

   stack <int>::size_type i;
   i = s1.size( );
   cout << "The stack length is " << i << "." << endl;

   i = s1.top( );
   cout << "The element at the top of the stack is "
        << i << "." << endl;

   s1.pop( );

   i = s1.size( );
   cout << "After a pop, the stack length is "
        << i << "." << endl;

   i = s1.top( );
   cout << "After a pop, the element at the top of the stack is "
        << i << "." << endl;
}

The stack length is 3.
The element at the top of the stack is 30.
After a pop, the stack length is 2.
After a pop, the element at the top of the stack is 20.

push

Adiciona um elemento ao topo da pilha.

void push(const Type& val);

Parâmetros

val
O elemento adicionado à parte superior da stack.

Comentários

O início da stack é a posição ocupada pelo elemento adicionado mais recentemente e é o último elemento no fim do contêiner.

Exemplo

// stack_push.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   stack <int> s1;

   s1.push( 10 );
   s1.push( 20 );
   s1.push( 30 );

   stack <int>::size_type i;
   i = s1.size( );
   cout << "The stack length is " << i << "." << endl;

   i = s1.top( );
   cout << "The element at the top of the stack is "
        << i << "." << endl;
}

The stack length is 3.
The element at the top of the stack is 30.

size

Retorna o número de elementos na stack.

size_type size() const;

Valor de retorno

O comprimento atual da stack.

Exemplo

// stack_size.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   stack <int> s1, s2;
   stack <int>::size_type i;

   s1.push( 1 );
   i = s1.size( );
   cout << "The stack length is " << i << "." << endl;

   s1.push( 2 );
   i = s1.size( );
   cout << "The stack length is now " << i << "." << endl;
}

The stack length is 1.
The stack length is now 2.

size_type

Um tipo de inteiro sem sinal que pode representar o número de elementos em uma stack.

typedef typename Container::size_type size_type;

Comentários

O tipo é um sinônimo de size_type do contêiner base adaptado pela stack.

Exemplo

Veja o exemplo de size que demonstra como declarar e usar size_type.

stack

Constrói uma stack que é vazia ou que é uma cópia de uma classe de contêiner base.

stack();

explicit stack(const container_type& right);

Parâmetros

right
O contêiner do qual a stack construída será uma cópia.

Exemplo

// stack_stack.cpp
// compile with: /EHsc
#include <stack>
#include <vector>
#include <list>
#include <iostream>

int main( )
{
   using namespace std;

   // Declares stack with default deque base container
   stack <char> dsc1;

   //Explicitly declares a stack with deque base container
   stack <char, deque<char> > dsc2;

   // Declares a stack with vector base containers
   stack <int, vector<int> > vsi1;

   // Declares a stack with list base container
   stack <int, list<int> > lsi;

   // The second member function copies elements from a container
   vector<int> v1;
   v1.push_back( 1 );
   stack <int, vector<int> > vsi2( v1 );
   cout << "The element at the top of stack vsi2 is "
        << vsi2.top( ) << "." << endl;
}

The element at the top of stack vsi2 is 1.

top

Retorna uma referência a um elemento na parte superior da stack.

reference top();

const_reference top() const;

Valor de retorno

Uma referência ao último elemento no contêiner na parte superior da stack.

Comentários

A stack não pode estar vazia para que seja possível aplicar a função membro. O início da stack é a posição ocupada pelo elemento adicionado mais recentemente e é o último elemento no fim do contêiner.

Se o valor retornado de top for atribuído a const_reference, o objeto stack não poderá ser modificado. Se o valor retornado de top for atribuído a um reference, o objeto stack poderá ser modificado.

Exemplo

// stack_top.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   stack <int> s1;

   s1.push( 1 );
   s1.push( 2 );

   int& i = s1.top( );
   const int& ii = s1.top( );

   cout << "The top integer of the stack s1 is "
        << i << "." << endl;
   i--;
   cout << "The next integer down is "<< ii << "." << endl;
}

The top integer of the stack s1 is 2.
The next integer down is 1.

value_type

Um tipo que representa o tipo de objeto armazenado como um elemento em uma stack.

typedef typename Container::value_type value_type;

Comentários

O tipo é um sinônimo de value_type do contêiner base adaptado pela stack.

Exemplo

// stack_value_type.cpp
// compile with: /EHsc
#include <stack>
#include <iostream>

int main( )
{
   using namespace std;
   // Declares stacks with default deque base container
   stack<int>::value_type AnInt;

   AnInt = 69;
   cout << "The value_type is AnInt = " << AnInt << endl;

   stack<int> s1;
   s1.push( AnInt );
   cout << "The element at the top of the stack is "
        << s1.top( ) << "." << endl;
}

The value_type is AnInt = 69
The element at the top of the stack is 69.

Confira também

Acesso Thread-Safe na Biblioteca Padrão C++
Referência da biblioteca padrão C++