Introducción a la STL

La Biblioteca de Plantillas Estándar (STL, Standard Template Libray) es una parte esencial de la biblioteca estándar de C++. Implementa el paradigma de programación genérica mediante plantillas (templates), proporcionando estructuras de datos y algoritmos reutilizables. Su diseño permite abstraer tipos específicos, facilitando la creación de código flexible y eficiente.

Los Seis Componentes Principales

La STL se compone de seis elementos clave: contenedores, iteradores, algoritmos, objetos función, adaptadores y asignadores. A continuación, se detallan los más relevantes.

Contenedores

Los contenedores almacenan colecciones de objetos. Se clasifican en secuenciales y asociativos.

Contenedores Secuenciales

• vector: Arreglo dinámico que permite acceso aleatorio. Inserción al final es eficiente, pero en posiciones intermedias es costosa.
• deque: Cola de doble extremo. Permite inserción rápida tanto al inicio como al final, con acceso aleatorio.
• list: Lista doblemente enlazada. Inserción y eliminación en cualquier posición son rápidas, pero no ofrece acceso aleatorio.

Contenedores Asociativos

• set / multiset: Almacenan elementos únicos o duplicados, respectivamente, ordenados automáticamente. Implementados con árboles blaanceados para búsqueda eficiente.
• map / multimap: Asocian claves con valores, manteniendo orden por clave. Permiten búsqueda rápida, con claves únicas o duplicadas.

Comparación de Contenedores

Iteradores

Los iteradores proporcionan una interfaz uniforme para recorrer elementos en contenedores, similar a punteros. Existen varios tipos: entrada, salida, adelante, bidireccional y acceso aleatorio. Cada contenedor soporta un tipo específico de iterador.

Operaciones comunes incluyen incremento (++), decremento (--), desreferencia (*) y comparación (==, !=). Los iteradores de acceso aleatorio permiten saltos arbitrarios con operadores como += y [] .

Algoritmos

Los algoritmos de la STL son funciones plantilla que operan en rangos definidos por iteradores. Se categorizan según su función.

• Búsqueda: Ejemplos como find, binary_search y adjacent_find.
• Ordenación: Incluye sort, stable_sort y partial_sort.
• Modificación: Algoritmos como copy, replace y remove.
• Numéricos: Funciones como accumulate y inner_product.

Adaptadores

Los adaptadores envuelven contenedores secuenciales para proporcionar interfaces específicas.

stack (Pila)

Implementa una estructura LIFO. Puede usar deque (por defecto), vector o list.

#include <stack>
using namespace std;

// Ejemplo con deque (predeterminado)
stack<int> pilaDeque;
// Ejemplo con vector
stack<int, vector<int>> pilaVector;
// Ejemplo con lista
stack<int, list<int>> pilaLista;

pilaDeque.push(10);
pilaDeque.push(20);
int cima = pilaDeque.top(); // 20
pilaDeque.pop();

queue (Cola)

Operación FIFO. Acepta deque (por defecto) o list como contenedor subyacente.

#include <queue>
using namespace std;

queue<int> colaDeque;
queue<int, list<int>> colaLista;

colaDeque.push(5);
colaDeque.push(15);
int frente = colaDeque.front(); // 5
colaDeque.pop();

priority_queue (Cola de Prioridad)

Mantiene elementos en orden de prioridad. Usa vector por defecto, con comparadores personalizables.

#include <queue>
#include <vector>
#include <functional>
using namespace std;

// Con prioridad por defecto (mayor primero)
priority_queue<int> colaMayor;
// Con prioridad menor primero
priority_queue<int, vector<int>, greater<int>> colaMenor;

// Ejemplo con estructura personalizada
struct Tarea {
    friend bool operator<(const Tarea& a, const Tarea& b) {
        return a.prioridad < b.prioridad;
    }
    int prioridad;
    string descripcion;
};

priority_queue<Tarea> colaTareas;
Tarea t1{2, "Revisión"};
colaTareas.push(t1);
Tarea cima = colaTareas.top(); // prioridad más alta