Milyen típusú iterátorokat ismersz?

A C++-ban az iterátorok általánosított mutatók, amelyek hozzáférést biztosítanak a konténer elemeihez és lehetővé teszik azok bejárását. A C++ szabvány szerint öt fő iterátortípus különböztethető meg, amelyek képességeik szerint növekvő sorrendben vannak rendezve:

• Bemeneti iterátorok:
  • Csak az elemek olvasására alkalmasak (operator*() const).
  • Az iterátor növelése (operator++()).
  • Egyenlőség-összehasonlítás (operator==(), operator!=()).
  • Példa: bemeneti adatfolyam iterátorok (std::istream_iterator).
• Kimeneti iterátorok:
  • Csak az elemek írására alkalmasak (operator*()).
  • Az iterátor növelése (operator++()).
  • Példa: kimeneti adatfolyam iterátorok (std::ostream_iterator).
• Egymás felé haladó iterátorok:
  • Minden bemeneti és kimeneti iterátor képességét támogatják.
  • Garantálják, hogy az iterátor növelése mindig a következő elemhez vagy a sorozat végéhez vezet.
  • Példa: egymás felé haladó listák (std::forward_list).
• Kétirányú iterátorok:
  • Minden egymás felé haladó iterátor képességét támogatják.
  • Lehetővé teszik az iterátor csökkentését (operator--()) a korábbi elemhez való visszatéréshez.
  • Példa: listák (std::list) és halmazok (std::set) iterátorai.
• Véletlen hozzáférésű iterátorok:
  • Minden kétirányú iterátor képességét támogatják.
  • Matematikai műveleteket végezhetnek az iterátorokon (összeadás/kivonás egész számokkal, iterátorok kivonása) gyors eléréshez.
  • Használhatják az [] operátort az elemek index szerinti eléréséhez.
  • Példa: vektorok (std::vector) és tömbök (std::array) iterátorai.

Ez a hierarchia azt feltételezi, hogy minden következő iterátortípus rendelkezik az összes előző képességével. Például a véletlen hozzáférésű iterátor is kétirányú, egymás felé haladó, egymás felé haladó, bemeneti és kimeneti iterátor is egyben.

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    // Véletlen hozzáférésű iterátor
    auto vec_it = vec.begin();
    vec_it += 2; // Véletlen hozzáférés
    std::cout << *vec_it << std::endl; // Kimenet: 3

    std::list<int> lst = {10, 20, 30};
    // Kétirányú iterátor
    auto list_it = lst.begin();
    ++list_it; // Növelés
    --list_it; // Csökkentés

    std::forward_list<int> flst = {100, 200, 300};
    // Egymás felé haladó iterátor
    auto flist_it = flst.begin();
    ++flist_it; // Csak növelés

    // Bemeneti iterátor
    std::istream_iterator<int> input_it(std::cin);
    // Kimeneti iterátor
    std::ostream_iterator<int> output_it(std::cout, " ");

    return 0;
}

Vannak továbbá iterátor-adapterek (pl. std::reverse_iterator, std::move_iterator), amelyek módosítják az alap iterátorok viselkedését.