Dominando std::stack en C++: Guía completa con ejemplos prácticos

¿Qué es std::stack?

std::stack es un adaptador de contenedor que implementa el principio LIFO (Last In, First Out – último en entrar, primero en salir). Permite inserción y eliminación de elementos solo desde un extremo: la cima. Por defecto, usa std::deque como contenedor subyacente, pero cualquier contenedor de secuencia (ej. std::vector o std::list) puede suministrarse.

Los adaptadores de contenedor no exponen iteradores, por lo que no puede recorrer una pila directamente. En su lugar, interactúa con ella a través de sus funciones miembro.

Objetivos de aprendizaje

• Definir std::stack y entender su comportamiento LIFO
• Aprender la sintaxis para declarar una pila
• Explorar tipos miembro y operaciones clave
• Trabajar con push, pop, top, empty, size, emplace y swap
• Implementar una pila en la Biblioteca Estándar de Plantillas (STL)

Sintaxis

Incluya la cabecera <stack> y declare una pila con la siguiente plantilla:

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

• T – Tipo de elemento; cualquier tipo válido en C++, incluidas clases definidas por el usuario.
• Container – Contenedor subyacente; por defecto std::deque.

Tipos miembro

• value_type – El tipo de elemento T.
• container_type – El tipo del contenedor subyacente.
• size_type – Tipo entero sin signo para el tamaño del contenedor.

Operaciones principales

• push() – Añade un elemento a la cima.
• pop() – Elimina el elemento de la cima.
• top() – Accede al elemento de la cima sin eliminarlo.
• empty() – Verifica si la pila no tiene elementos.
• size() – Devuelve el número de elementos.
• emplace() – Construye e inserta un elemento directamente en la cima.
• swap() – Intercambia contenidos con otra pila.

Visión general de la implementación

A continuación, una representación visual de las operaciones de pila (la cima indicada por el puntero).

push() y pop()

El método push() agrega un nuevo elemento, aumentando el tamaño en uno:

pila.push(valor);

Por el contrario, pop() elimina el elemento de la cima y reduce el tamaño:

pila.pop();

Ejemplo 1: Manipulación básica de pila

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

Salida: 20 10

empty(), size(), top()

Estas funciones utilitarias proporcionan información rápida sobre el estado de la pila.

Ejemplo 2: Inspección del estado de la pila

#include <iostream>
#include <stack>
using namespace std;
void mostrar(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 << "La pila st es: ";
    mostrar(st);
    cout << "\n st.size() : " << st.size();
    cout << "\n st.top() : " << st.top();
    st.pop();
    cout << "\n st después de pop: ";
    mostrar(st);
    return 0;
}

Salida: muestra contenidos de la pila, tamaño, elemento superior y estado tras un pop.

emplace() y swap()

• emplace() construye un elemento in-place, evitando una copia extra.
• swap() intercambia los contenidos de dos pilas eficientemente.

Ejemplo 3: Uso de emplace() y 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();
    }
}

Salida: demuestra los contenidos de las pilas antes y después del intercambio.

Uso de std::stack en STL

Implemente una pila con una sola línea:

std::stack<T> st;

Ejemplo:

#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;
}

Resumen

• std::stack implementa LIFO y solo permite acceso al elemento superior.
• Es un adaptador de contenedor; el contenedor subyacente por defecto es std::deque, pero puede personalizarse.
• Funciones principales: push, pop, top, empty, size, emplace, swap.
• La pila es una herramienta ligera y eficiente para escenarios que requieren almacenamiento temporal de elementos.