Que tipos de iteradores conheces?

Os iteradores em C++ representam ponteiros genéricos que fornecem acesso aos elementos do contêiner e a capacidade de percorrê-los. De acordo com o padrão C++, distinguem-se 5 categorias principais de iteradores, ordenadas por aumento de capacidades:

• Iteradores de entrada (Input iterators):
  • Permitem apenas leitura dos elementos (operator*() const).
  • Permitem incrementar o iterador (operator++()).
  • Suportam comparação de igualdade (operator==(), operator!=()).
  • Exemplo: iteradores para fluxos de entrada (std::istream_iterator).
• Iteradores de saída (Output iterators):
  • Permitem apenas escrita nos elementos (operator*()).
  • Permitem incrementar o iterador (operator++()).
  • Exemplo: iteradores para fluxos de saída (std::ostream_iterator).
• Iteradores forward (Forward iterators):
  • Suportam todas as capacidades de iteradores de entrada e saída.
  • Garantem que incrementar o iterador leva sempre ao próximo elemento ou ao final da sequência.
  • Exemplo: iteradores para listas ligadas simples (std::forward_list).
• Iteradores bidirecionais (Bidirectional iterators):
  • Suportam todas as capacidades dos iteradores forward.
  • Permitem decrementar o iterador (operator--()) para mover ao elemento anterior.
  • Exemplo: iteradores para listas (std::list) e conjuntos (std::set).
• Iteradores de acesso aleatório (Random access iterators):
  • Suportam todas as capacidades dos iteradores bidirecionais.
  • Permitem realizar operações aritméticas com os iteradores (adição/subtração de inteiros, subtração de iteradores) para acesso rápido a qualquer elemento.
  • Permitem usar o operador [] para acesso por índice.
  • Exemplo: iteradores para vetores (std::vector) e arrays (std::array).

Esta hierarquia implica que cada categoria posterior de iteradores possui as capacidades de todas as anteriores. Por exemplo, um iterador de acesso aleatório também é bidirecional, forward, de entrada e de saída.

#include <vector>
#include <list>
#include <forward_list>
#include <iostream>
#include <iterator>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    // Iterador de acesso aleatório
    auto vec_it = vec.begin();
    vec_it += 2; // Acesso aleatório
    std::cout << *vec_it << std::endl; // Saída: 3

    std::list<int> lst = {10, 20, 30};
    // Iterador bidirecional
    auto list_it = lst.begin();
    ++list_it; // Incremento
    --list_it; // Decremento

    std::forward_list<int> flst = {100, 200, 300};
    // Iterador forward
    auto flist_it = flst.begin();
    ++flist_it; // Apenas incremento

    // Iterador de entrada
    std::istream_iterator<int> input_it(std::cin);
    // Iterador de saída
    std::ostream_iterator<int> output_it(std::cout, " ");

    return 0;
}

Existem também adaptadores de iteradores (por exemplo, std::reverse_iterator, std::move_iterator), que alteram o comportamento dos iteradores básicos.