Empilhar em C++ STL com exemplo

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

• Tipo – é o tipo de elemento contido no std::stack. Pode ser qualquer tipo C++ válido ou até mesmo um tipo definido pelo usuário.
• Contêiner – é o tipo de objeto de contêiner subjacente.

Tipos de membros

• value_type- O primeiro parâmetro do template, T. Ele denota os tipos de elementos.
• container_type- O segundo parâmetro de modelo, Container. Denota o tipo de contêiner subjacente.
• size_type- Tipo integral não assinado.

Operações na pilha

• push – Adiciona/empurra um item para a pilha.
• pop – Remove/remove um item da pilha.
• peek – Retorna o item do topo da pilha sem removê-lo.
• isFull – Verifica se uma pilha está cheia.
• isEmpty – Verifica se uma pilha está vazia.

Implementação da pilha

Etapa 1) Inicialmente temos uma pilha vazia. O topo de uma pilha vazia é definido como -1.

Etapa 2) Em seguida, colocamos o elemento 5 na pilha. O topo da pilha apontará para o elemento 5.

Etapa 3) Em seguida, colocamos o elemento 50 na pilha. O topo da pilha se desloca e aponta para o elemento 50.

Etapa 4) Em seguida, realizamos uma operação pop, removendo o elemento do topo da pilha. O elemento 50 é retirado da pilha. O topo da pilha agora aponta para o elemento 5.

push() e pop()

stack.push(value)

stack.pop()

Exemplo 1:

#include <iostream> 
#include <stack> 
using namespace std;
int main() {
	stack<int> st;
	st.push(10);
	st.push(20);
	st.push(30);
	st.push(40);
	
         st.pop();
	st.pop();

	while (!st.empty()) {
		cout << ' ' << st.top();
		st.pop();
	}
}

Aqui está uma captura de tela do código:

Explicação do código:

1. Inclua o arquivo de cabeçalho iostream em nosso código para usar suas funções.
2. Inclua o arquivo de cabeçalho da pilha em nosso código para usar suas funções.
3. Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
4. Chame a função main(). A lógica do programa deve ser adicionada dentro desta função.
5. Crie uma pilha st para armazenar valores inteiros.
6. Use a função push() para inserir o valor 10 na pilha.
7. Use a função push() para inserir o valor 20 na pilha.
8. Use a função push() para inserir o valor 30 na pilha.
9. Use a função push() para inserir o valor 40 na pilha.
10. Use a função pop() para remover o elemento superior da pilha, ou seja, 40. O elemento superior agora se torna 30.
11. Use a função pop() para remover o elemento superior da pilha, ou seja, 30. O elemento superior agora se torna 20.
12. Use um loop while e uma função empty() para verificar se a pilha NÃO está vazia. O ! é o operador NOT.
13. Imprimindo o conteúdo atual da pilha no console.
14. Chame a função pop() na pilha.
15. Fim do corpo do loop while.
16. Fim do corpo da função main().

vazio(), tamanho(), topo()

• empty()- verifica se uma pilha está vazia ou não.
• size()- retorna o tamanho da pilha, ou seja, o número de elementos em uma pilha.
• top()- acessa o elemento da pilha no topo.

Exemplo 2:

#include <iostream> 
#include <stack>  
using namespace std;
void createStack(stack <int> mystack)
{
	stack <int> ms = mystack;
	while (!ms.empty())
	{
		cout << '\t' << ms.top();
		ms.pop();
	}
	cout << '\n';
}
int main()
{
	stack <int> st;
	st.push(32);
	st.push(21);
	st.push(39);
	st.push(89);
	st.push(25);

	cout << "The stack st is: ";
	createStack(st);
	cout << "\n st.size() : " << st.size();
	cout << "\n st.top() : " << st.top();
	cout << "\n st.pop() : ";
	st.pop();
	createStack(st);
	return 0;
}

Aqui está uma captura de tela do código:

Explicação do código:

1. Inclua o arquivo de cabeçalho iostream em nosso código para usar suas funções.
2. Inclua o arquivo de cabeçalho da pilha em nosso código para usar suas funções.
3. Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
4. Crie a função createStack que podemos usar para criar a pilha mystack. A pilha conterá um conjunto de inteiros.
5. O início do corpo da função createStack.
6. Crie uma instância do tipo de dados mystack e dê a ela o nome ms.
7. Use o loop while e a função empty() para verificar se a pilha está vazia.
8. O início do corpo do loop while.
9. Use a função top() armazenada no topo da pilha. O caractere \t criará uma nova guia.
10. Use a função pop() para excluir o elemento no topo da pilha.
11. Fim do corpo do loop while.
12. Imprima uma linha em branco no console.
13. Fim do corpo da função createStack.
14. Chame a função main(). A lógica do programa deve ser adicionada ao corpo da função main().
15. O início do corpo da função main().
16. Crie um objeto de pilha st.
17. Use a função push() para inserir o elemento 32 na pilha.
18. Use a função push() para inserir o elemento 21 na pilha.
19. Use a função push() para inserir o elemento 39 na pilha.
20. Use a função push() para inserir o elemento 89 na pilha.
21. Use a função push() para inserir o elemento 25 na pilha.
22. Imprima algum texto no console.
23. Chame a função createStack para executar as operações de inserção acima na pilha.
24. Imprima o tamanho da pilha no console junto com outro texto.
25. Imprima o elemento no topo da pilha no console.
26. Imprima algum texto no console.
27. Exclua o elemento no topo da pilha. Em seguida, ele retornará os elementos restantes na pilha.
28. Chame a função createStack para executar as operações acima.
29. O programa deve retornar o valor após a conclusão bem-sucedida.
30. Fim do corpo da função main().

emplace() e swap()

• emplace()- constrói e insere um novo elemento no topo da pilha.
• swap()- troca o conteúdo da pilha com o conteúdo de outra pilha.

Exemplo 3:

#include <iostream>    
#include <stack>
#include <cstdlib>
using namespace std;
int main() {
	stack<int> st1;
	stack<int> st2;

	st1.emplace(12);
	st1.emplace(19);

	st2.emplace(20);
	st2.emplace(23);

	st1.swap(st2);

	cout << "st1 = ";
	while (!st1.empty()) {
		cout << st1.top() << " ";
		st1.pop();
	}

	cout << endl << "st2 = ";
	while (!st2.empty()) {
		cout << st2.top() << " ";
		st2.pop();
	}
}

Aqui está uma captura de tela do código:

Explicação do código:

1. Inclua o arquivo de cabeçalho iostream em nosso código para usar suas funções.
2. Inclua o arquivo de cabeçalho da pilha em nosso código para usar suas funções.
3. Inclua o arquivo de cabeçalho cstdlib em nosso código para usar suas funções.
4. Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
5. Chame a função main(). A lógica do programa será adicionada no corpo desta função.
6. Declare uma pilha chamada st1 para armazenar valores inteiros.
7. Declare uma pilha chamada st2 para armazenar valores inteiros.
8. Use a função emplace() para inserir o inteiro 12 na pilha chamada st1.
9. Use a função emplace() para inserir o inteiro 19 na pilha chamada st1.
10. Use a função emplace() para inserir o inteiro 20 na pilha chamada st2.
11. Use a função emplace() para inserir o inteiro 23 na pilha chamada st2.
12. Use a função swap() para trocar o conteúdo das duas pilhas, st1 e st2. O conteúdo da pilha st1 deve ser movido para a pilha st2. O conteúdo da pilha st2 deve ser movido para a pilha st1.
13. Imprima algum texto no console.
14. Use a instrução while e a função empty() para verificar se a pilha st1 não está vazia.
15. Imprima o conteúdo da pilha st1 no console. O ” ” adiciona espaço entre os elementos da pilha ao imprimi-los no console.
16. Execute a função pop() na pilha st1 para remover o elemento superior.
17. Fim do corpo da instrução while.
18. Imprima algum texto no console. O endl é uma palavra-chave C++ para linha final. Ele move o cursor do mouse para a próxima linha para começar a imprimir a partir daí.
19. Use a instrução while e a função empty() para verificar se a pilha st2 não está vazia.
20. Imprima o conteúdo da pilha st2 no console. O ” ” adiciona espaço entre os elementos da pilha ao imprimi-los no console.
21. Execute a função pop() na pilha st2 para remover o elemento superior.
22. Fim do corpo da instrução while.
23. Fim do corpo da função main().

Pilha em STL

stack<T> st; 

Exemplo 3:

#include <iostream>      
#include <stack>
#include <cstdlib>
using namespace std;
int main() {
	stack<int> st;
	st.push(12);
	st.push(19);
	st.push(20);
	cout << st.top();   
	cout << st.size();  
}

Aqui está uma captura de tela do código:

Explicação do código:

1. Inclua o arquivo de cabeçalho iostream em nosso código para usar suas funções.
2. Inclua o arquivo de cabeçalho da pilha em nosso código para usar suas funções.
3. Inclua o arquivo de cabeçalho cstdlib em nosso código para usar suas funções.
4. Inclua o namespace std em nosso código para usar suas classes sem chamá-lo.
5. Chame a função main(). A lógica do programa deve ser adicionada no corpo desta função.
6. Declare uma pilha st para armazenar dados inteiros.
7. Adicione o elemento 12 à pilha.
8. Adicione o elemento 19 à pilha.
9. Adicione o elemento 20 à pilha.
10. Imprima o elemento no topo da pilha no console.
11. Imprima o tamanho da pilha no console.
12. Fim do corpo da função main().

Resumo:

• Uma pilha é uma estrutura de dados que opera com base na técnica LIFO (Last In first Out).
• O std::stack só permite que itens sejam adicionados e removidos de uma extremidade.
• A classe std::stack é um adaptador de contêiner, contendo itens de um tipo de dados semelhante.
• Uma pilha pode ser criada a partir de vários contêineres de sequência.
• Se você não fornecer um contêiner, o contêiner deque será usado por padrão.
• A função push() serve para inserir itens na pilha.
• A função pop() serve para remover o item superior da etapa.
• A função empty() serve para verificar se uma pilha está vazia ou não.