Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::adjacent_view
Member functions
(C++26)
Iterator
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
template < bool Const >
class /*iterator*/
(seit C++23)
( nur zur Darstellung* )

Der Rückgabetyp von adjacent_view::begin , und von adjacent_view::end wenn die zugrunde liegende Ansicht V ein 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.

Inhaltsverzeichnis

Mitgliedertypen

Mitgliedtyp Definition
Base (private) const V falls Const gleich true ist, andernfalls V .
( Nur zur Darstellung verwendeter Mitgliedtyp* )
iterator_category std:: input_iterator_tag
iterator_concept
value_type std:: tuple < /*REPEAT*/ ( ranges:: range_value_t < Base > , N ) ... > ;
difference_type ranges:: range_difference_t < Base >

Datenmitglieder

Member-Objekt Definition
current_ (private) std:: array < ranges:: iterator_t < Base > , N > .
( Nur-Darstellungs-Member-Objekt* )

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