Iteradores de entrada

Los iteradores de entrada proporcionan una interfaz de solo lectura para recorrer estructuras de datos, con semántica de paso único. Son ideales para operaciones secuenciales donde cada posición se accede una vez antes de avanzar. Características esenciales incluyen movimiento hacia adelante mediante el operador ++, desreferencia para obtener el valor actual, e imposibilidad de reutilizar posiciones anteriores después del incremento.

Ejemplo de uso con un iterador de entrada para leer datos de flujo:

#include <iostream>
#include <iterator>
#include <vector>

int main() {
    std::istream_iterator<float> inicio_flujo(std::cin), fin_flujo;
    std::vector<float> datos(inicio_flujo, fin_flujo);
    std::ostream_iterator<float> salida(std::cout, "; ");
    std::copy(datos.begin(), datos.end(), salida);
    return 0;
}

Comparación entre categorías de iteradores:

Iteradores de salida

Los iteradores de salida permiten escribir datos en una secuencia, pero no admiten lectura. Se utilizan para algoritmos de copia y transformación. Su identificación en tiempo de compilación se logra mediante traits de tipo como std::iterator_traits.

Validación estática de la categoría del iterador:

template<typename Iter>
using etiqueta_iterador = typename std::iterator_traits<Iter>::iterator_category;

static_assert(std::is_same_v<etiqueta_iterador<IterSalida>, std::output_iterator_tag>);

Especialización de plantillas para optimizar el rendimiento de escritura:

template<typename T>
struct EscritorDatos {
    void escribir(const T& valor) { /* Implementación genérica */ }
};

template<>
struct EscritorDatos<int> {
    void escribir(const int& valor) {
        flujo.write(reinterpret_cast<const char*>(&valor), sizeof(valor));
    }
};

Uso de static_assert para restricciones en tiempo de compilación:

template<typename T>
void enviar(const T& elemento) {
    static_assert(std::is_arithmetic_v<T>, "El tipo debe ser numérico");
    // Lógica de procesamiento segura
}

Implementación de un iterador de salida basado en metaprogramación:

template<typename U>
struct IteradorMetaSalida {
    U* puntero;
    using tipo_valor = void;
    IteradorMetaSalida& operator*() { return *this; }
    IteradorMetaSalida& operator=(const U& val) {
        static_assert(std::is_copy_constructible_v<U>, "El tipo debe ser copiable");
        *puntero = val;
        return *this;
    }
};

Aplicación en generación de código basada en tipos:

void generar_campos(std::ostream& destino, const std::vector<Campo>& lista) {
    for (const auto& campo : lista) {
        destino << "campo: " << campo.nombre << ", tipo: " << campo.tipo << std::endl;
    }
}

Iteradores hacia adelante

Los iteradores hacia adelante admiten lectura, escritura y movimiento unidireccional. Su semántica principal es garantizar que cada posición se visite a lo sumo una vez durante un recorrido. La identificación en tiempo de compilación se facilita mediante traits especializados.

Extracción de la categoría del iterador:

template<typename Iter>
using cat_iterador = typename std::iterator_traits<Iter>::iterator_category;

template<typename Iter>
constexpr bool es_hacia_adelante = 
    std::is_same_v<cat_iterador<Iter>, std::forward_iterator_tag>;

Detección de capacidades mediante SFINAE:

template<typename T>
class SoporteAdelante {
    template<typename U>
    static auto probar(U* u) -> decltype(*u, ++u, void(), std::true_type{});
    
    static std::false_type probar(...);
public:
    static constexpr bool valor = decltype(probar<T>(nullptr))::value;
};

Estructura básica de un iterador hacia adelante:

template<typename T>
class IteradorAdelante {
    T* posicion;
public:
    explicit IteradorAdelante(T* p) : posicion(p) {}
    T& operator*() { return *posicion; }
    IteradorAdelante& operator++() { ++posicion; return *this; }
    bool operator!=(const IteradorAdelante& otro) const { return posicion != otro.posicion; }
};

Iteradores bidireccionales

Los iteradores bidireccionales extienden la funcionalidad hacia adelante al permitir movimiento tanto hacia adelante como hacia atrás. Deben cumplir restricciones de interfaz definidas en tiempo de compilación, como operadores de incremento y decremento.

Definición estándar de un iterador bidireccional:

template<typename T>
struct IteradorBidireccional {
    using etiqueta_categoria = std::bidirectional_iterator_tag;
    using tipo_valor = T;
    using tipo_diferencia = std::ptrdiff_t;
    using puntero = T*;
    using referencia = T&;

    IteradorBidireccional& operator++();
    IteradorBidireccional& operator--();
};

Estructura de metadatos para soporte de navegación inversa:

template<typename NodoAnterior, int Valor>
struct NodoMeta {
    static constexpr int valor = Valor;
    using anterior = NodoAnterior;
};

struct NodoNulo {};

Optimización de recorrido inverso mediante recursión de cola:

template<typename Lista, typename Acumulador>
struct InversorImpl;

template<template<int...> class Contenedor, int... Acum>
struct InversorImpl<Contenedor<>, Contenedor<Acum...>> {
    using tipo = Contenedor<Acum...>;
};

template<template<int...> class Contenedor, int Cabeza, int... Cola, int... Acum>
struct InversorImpl<Contenedor<Cabeza, Cola...>, Contenedor<Acum...>> {
    using tipo = typename InversorImpl<Contenedor<Cola...>, Contenedor<Cabeza, Acum...>>::tipo;
};

Uso de Conceptos para imponer comportamiento bidireccional:

template<typename T>
concept Bidireccional = requires(T a) {
    { --a } -> std::same_as<T&>;
    { a-- } -> std::same_as<T>;
    requires std::ForwardIterator<T>;
};

Iteradores de acceso aleatorio

Los iteradores de acceso aleatorio ofrecen la mayor flexibilidad, permitiendo acceso directo a cualquier posición en tiempo constante. Soportan operaciones aritméticas, como suma y resta de enteros, y operaciones relacionales, como comparación de orden.

Operaciones típicas habilitadas:

• Desplazamiento con operadores + y -
• Cálculo de distancia entre dos iteradores
• Acceso mediante operador de subíndice
• Comparaciones como menor que o mayor que

Contenedores estándar que los proporcionan:

Ejemplo de uso con operaciones de acceso aleatorio:

#include <vector>
#include <iostream>

int main() {
    std::vector<double> coleccion = {1.2, 3.4, 5.6, 7.8, 9.0};
    auto it = coleccion.begin();

    it += 3;
    std::cout << *it << std::endl;  // Salida: 7.8

    std::cout << it[1] << std::endl;  // Salida: 9.0

    auto longitud = coleccion.end() - coleccion.begin();
    std::cout << "Longitud: " << longitud << std::endl;  // Salida: 5
}

Ventaja de rendimiento: Algoritmos como std::sort y std::binary_search dependen de iteradores de acceso aleatorio para alcanzar complejidades logarítmicas o lineal-logarítmicas.