Dominando std::stack em C++: Guia Completo com Exemplos Práticos

O que é std::stack?

std::stack é um adaptador de container que implementa o princípio LIFO (Last In, First Out – Último a Entrar, Primeiro a Sair). Ele permite inserção e remoção de elementos apenas em uma extremidade – o topo. Por padrão, usa std::deque como container subjacente, mas qualquer container de sequência (ex.: std::vector ou std::list) pode ser fornecido.

Adaptadores de container não expõem iteradores, então você não pode percorrer uma stack diretamente. Em vez disso, você interage com ela através de suas funções membro.

Objetivos de Aprendizado

• Definir std::stack e entender seu comportamento LIFO
• Aprender a sintaxe para declarar uma stack
• Explorar tipos membro e operações-chave
• Trabalhar com push, pop, top, empty, size, emplace e swap
• Implementar uma stack na Standard Template Library (STL)

Sintaxe

Inclua o cabeçalho <stack> e declare uma stack com o seguinte template:

template<class T, class Container = std::deque<T>> class stack;

• T – Tipo do elemento; qualquer tipo C++ válido, incluindo classes definidas pelo usuário.
• Container – Container subjacente; padrão para std::deque.

Tipos Membro

• value_type – O tipo do elemento T.
• container_type – O tipo do container subjacente.
• size_type – Tipo integral sem sinal para tamanho do container.

Operações Principais

• push() – Adiciona elemento ao topo.
• pop() – Remove o elemento do topo.
• top() – Acessa o elemento do topo sem remoção.
• empty() – Verifica se a stack não tem elementos.
• size() – Retorna o número de elementos.
• emplace() – Constrói e insere elemento diretamente no topo.
• swap() – Troca conteúdo com outra stack.

push() e pop()

O método push() anexa um novo elemento, aumentando o tamanho em um:

stack.push(valor);

Por outro lado, pop() remove o elemento do topo e reduz o tamanho:

stack.pop();

Exemplo 1: Manipulação Básica de Stack

#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(); // remove 40
    st.pop(); // remove 30
    while (!st.empty()) {
        cout << ' ' << st.top();
        st.pop();
    }
    return 0;
}

Saída: 20 10

empty(), size(), top()

Estas funções utilitárias fornecem insights rápidos sobre o estado da stack.

Exemplo 2: Inspecionando Estado da Stack

#include <iostream>
#include <stack>
using namespace std;
void exibir(stack<int> s) {
    while (!s.empty()) {
        cout << '\t' << s.top();
        s.pop();
    }
    cout << '\n';
}
int main() {
    stack<int> st;
    st.push(32);
    st.push(21);
    st.push(39);
    st.push(89);
    st.push(25);
    cout << "A stack st é: ";
    exibir(st);
    cout << "\n st.size(): " << st.size();
    cout << "\n st.top(): " << st.top();
    st.pop();
    cout << "\n st após pop: ";
    exibir(st);
    return 0;
}

Saída: mostra conteúdo da stack, tamanho, elemento do topo e estado após pop.

emplace() e swap()

• emplace() constrói um elemento in-place, evitando cópia extra.
• swap() troca o conteúdo de duas stacks eficientemente.

Exemplo 3: Usando emplace() e swap()

#include <iostream>
#include <stack>
using namespace std;
int main() {
    stack<int> st1, 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();
    }
}

Saída: demonstra conteúdo das stacks antes e depois da troca.

Usando std::stack na STL

Implemente uma stack com uma única linha:

std::stack<T> st;

Exemplo:

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

Resumo

• std::stack implementa LIFO e só permite acesso ao elemento do topo.
• É um adaptador de container; container subjacente padrão é std::deque, mas pode ser personalizado.
• Funções principais: push, pop, top, empty, size, emplace, swap.
• Stack é uma ferramenta leve e eficiente para cenários que requerem armazenamento temporário de elementos.