Namespaces
Variants

    std::ranges::adjacent_view<V,N>::iterator

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Bereichsadaptoren
     
    std::ranges::adjacent_view
    Mitgliedsfunktionen
    (C++26)
    Iterator
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Sentinel
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
     
    template< bool Const >
class /*iterator*/
    		(seit C++23)
    (nur zur Veranschaulichung*)

    Der Rückgabetyp von adjacent_view::begin, und von adjacent_view::end wenn die zugrunde liegende View V eine common_range ist.

    Der Typ /*iterator*/<true> wird von den const-qualifizierten Überladungen zurückgegeben. Der Typ /*iterator*/<false> wird von den nicht-const-qualifizierten Überladungen zurückgegeben.

    Mitgliedstypen

    Mitglied Definition
    Base (private) maybe-const <Const, V>
    (nur zur Darstellung dienender Elementtyp*)
    iterator_category std::input_iterator_tag
    iterator_concept
    • std::random_access_iterator_tag, wenn Base random_access_range modelliert. Andernfalls,
    • std::bidirectional_iterator_tag, wenn Base bidirectional_range modelliert. Andernfalls,
    • std::forward_iterator_tag.
    value_type std::tuple</*REPEAT*/(ranges::range_value_t<Base>, N)...>;
    difference_type ranges::range_difference_t<Base>

    Datenmitglieder

    Mitglied Beschreibung
    std::array<ranges::iterator_t<Base>, N> current_ (privat) ein Array von Iteratoren
    (nur zur Erläuterung Mitgliedsobjekt*)

    Memberfunktionen

    		Konstruiert einen Iterator
    (öffentliche Elementfunktion)
    		greift auf das Element zu
    (öffentliche Elementfunktion)
    		greift auf ein Element per Index zu
    (öffentliche Elementfunktion)
    		bewegt die zugrundeliegenden Iteratoren vor oder zurück
    (öffentliche Elementfunktion)

    Nicht-Member-Funktionen

    (C++23)
    		vergleicht die zugrundeliegenden Iteratoren
    (Funktion)
    (C++23)
    		führt Iterator-Arithmetik durch
    (Funktion)
    (C++23)
    		konvertiert das Ergebnis der Dereferenzierung des zugrundeliegenden Iterators in seinen zugehörigen Rvalue-Referenztyp
    (Funktion)
    (C++23)
    		vertauscht die von zwei zugrundeliegenden Iteratoren referenzierten Objekte
    (Funktion)

    Beispiel

    Diesen Code ausführen 
    #include <cassert>
#include <concepts>
#include <list>
#include <ranges>
#include <tuple>
#include <utility>
#include <vector>
int main()
{
    auto v = std::vector{0, 1, 2, 3, 4, 5};
    auto i = (v | std::views::adjacent<3>).begin();
    using I = decltype(i);
    static_assert(std::same_as<I::value_type, std::tuple<int, int, int>>);
    static_assert(std::same_as<I::iterator_concept, std::random_access_iterator_tag>);
    // einige verfügbare Operatoren:
    ++i; i++; --i; i--; i += 2; i -= 2;
    assert(i[2] == std::tuple(2, 3, 4));
    using DI = decltype(*i);
    static_assert(std::same_as<DI, std::tuple<int&, int&, int&>>);
    std::get<1>(*i) = 42; // modifiziert v[1] über Iterator i
    assert(v[1] == 42);
    auto l = std::list{0, 1, 2, 3, 4, 5};
    auto j = (l | std::views::adjacent<3>).begin();
    using J = decltype(j);
    static_assert(std::same_as<J::value_type, std::tuple<int, int, int>>);
    static_assert(std::same_as<J::iterator_concept, std::bidirectional_iterator_tag>);
    ++j; --j; j++; j--; // einige verfügbare Operatoren
    // j += 2; j -= 2;       // Fehler: diese Operatoren sind nicht verfügbar
    // std::ignore() = j[1]; //        für bidirektionale Iteratoren
}

    Referenzen

    • C++23-Standard (ISO/IEC 14882:2024):
    • 26.7.25.3 Klassentemplate adjacent_view::iterator [range.adjacent.iterator]

    Siehe auch