📦 CPP Module 08 – Contenedores Templados, Iteradores y Algoritmos

✅ Objetivo: Aprender y dominar el uso de los contenedores STL, iteradores y algoritmos en C++98, para manipular colecciones de datos de forma eficiente y segura.
✅ Nivel: Avanzado
✅ Temas clave: STL containers (vector, list, stack, etc.), algoritmos (find, sort, etc.), rango de iteradores, mutabilidad, excepciones, diseño seguro y práctico.

1. ¿Qué son los contenedores, iteradores y algoritmos STL?
2. Reglas Específicas del Módulo
3. Ejercicio 00 – EasyFind
4. Ejercicio 01 – Span
5. Ejercicio 02 – MutantStack
6. Tabla Resumen de STL y Algoritmos
7. Errores Comunes
8. Buenas Prácticas

La STL (Standard Template Library) de C++ proporciona herramientas genéricas y reutilizables para la gestión de colecciones de datos:

• Contenedores STL: Clases genéricas como vector, list, stack, map, etc., que almacenan y organizan datos de cualquier tipo.
• Iteradores: Objetos que permiten recorrer los elementos de un contenedor de manera uniforme, similar a los punteros.
• Algoritmos: Funciones como find, sort, copy, for_each, etc., que operan sobre rangos definidos por iteradores, permitiendo manipular los datos de los contenedores eficientemente.

El dominio de estos elementos es fundamental para programar en C++ de forma moderna, limpia y eficiente.

• ¡Usa la STL!
  • Se permite y se espera el uso de contenedores y algoritmos estándar (vector, list, stack, <algorithm>, etc.).
  • No usar la STL será penalizado incluso si el código funciona.
  • Puedes definir templates en el header, o dividir en .hpp y .tpp.

Objetivo:
Crear una función template easyfind que, dado un contenedor de enteros y un valor, busque la primera ocurrencia de ese valor usando algoritmos STL.

Puntos clave:

• Debe aceptar cualquier contenedor estándar de enteros (vector, list, etc.).
• Retornar un iterador al elemento encontrado, o lanzar una excepción si no existe.
• Inspirarse en el comportamiento de los algoritmos STL (std::find).

Ejemplo de uso:

std::vector<int> v = {1, 2, 3, 4};
try {
    std::vector<int>::iterator it = easyfind(v, 3);
    std::cout << "Encontrado: " << *it << std::endl;
} catch (std::exception &e) {
    std::cout << "No encontrado" << std::endl;
}

Objetivo:
Implementar una clase Span capaz de almacenar hasta N enteros y calcular la distancia mínima y máxima entre sus elementos.

Puntos clave:

• Constructor recibe N (máximo de elementos a almacenar).
• addNumber(int): Agrega un número. Lanza excepción si se rebasa la capacidad.
• shortestSpan(): Devuelve la menor diferencia entre elementos. Lanza excepción si no hay al menos dos números.
• longestSpan(): Devuelve la mayor diferencia entre elementos. Lanza excepción si no hay al menos dos números.
• Permite agregar múltiples números usando un rango de iteradores.
• Testea con al menos 10.000 números.

Ejemplo de uso:

Span sp(5);
sp.addNumber(6);
sp.addNumber(3);
sp.addNumber(17);
sp.addNumber(9);
sp.addNumber(11);

std::cout << sp.shortestSpan() << std::endl; // 2
std::cout << sp.longestSpan() << std::endl;  // 14

Objetivo:
Extender std::stack para hacerla iterable mediante iteradores, manteniendo toda su funcionalidad.

Puntos clave:

• Implementar una clase template MutantStack basada en std::stack.
• Añadir iteradores (begin(), end()) para recorrer los elementos.
• El resto de funciones (push, pop, top, size, etc.) deben comportarse igual que en std::stack.
• El comportamiento debe ser equivalente al de otros contenedores iterables (list, etc.) al iterar y mostrar los elementos.

Ejemplo de uso:

MutantStack<int> mstack;
mstack.push(5);
mstack.push(17);
std::cout << mstack.top() << std::endl; // 17
mstack.pop();
std::cout << mstack.size() << std::endl; // 1
mstack.push(3);
mstack.push(5);
mstack.push(737);
mstack.push(0);

for (MutantStack<int>::iterator it = mstack.begin(); it != mstack.end(); ++it)
    std::cout << *it << std::endl;

❌ No usar STL donde es requerido
❌ No lanzar excepciones en casos límite (capacidad, span con <2 elementos, etc.)
❌ No testear con suficientes datos (p.ej. <10,000 en Span)
❌ Olvidar include guards o violar normas de nomenclatura
❌ No implementar iteradores en MutantStack
❌ Fugas de memoria o mal manejo de recursos

✅ Prefiere algoritmos STL antes que bucles manuales
✅ Usa excepciones estándar (std::exception, etc.)
✅ Documenta el comportamiento esperado de cada función
✅ Haz pruebas con distintos contenedores y casos límite
✅ Usa const & y typedef para mayor claridad y eficiencia
✅ Escribe código claro, legible y fácilmente evaluable

_{Javier Fernández Correa}

Este proyecto está bajo la licencia MIT.