Namespaces
Variants
Views
Actions

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

From cppreference.com
 
 
Ranges library
Range adaptors
 
 
template< bool Const >
class /*iterator*/
(since C++23)
(exposition only*)

The return type of adjacent_view::begin, and of adjacent_view::end when the underlying view V is a common_range.

The type /*iterator*/<true> is returned by the const-qualified overloads. The type /*iterator*/<false> is returned by the non-const-qualified overloads.

Contents

[edit] Member types

Member type Definition
Base (private) const V if Const is true, otherwise V.
(exposition-only member type*)
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>

[edit] Data members

Member object Definition
current_ (private) std::array<ranges::iterator_t<Base>, N>.
(exposition-only member object*)

[edit] Member functions

constructs an iterator
(public member function)
accesses the element
(public member function)
accesses an element by index
(public member function)
advances or decrements the underlying iterators
(public member function) [edit]

[edit] Non-member functions

compares the underlying iterators
(function)
performs iterator arithmetic
(function)
(C++23)
casts the result of dereferencing the underlying iterator to its associated rvalue reference type
(function)
(C++23)
swaps the objects pointed to by two underlying iterators
(function)

[edit] Example

#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>);
    // some of available operators:
    ++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; // modifies v[1] via 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--; // some of available operators
    // j += 2; j -= 2;       // error: these operator are not available
    // std::ignore() = j[1]; //        for bidirectional iterator
}

[edit] References

  • C++23 standard (ISO/IEC 14882:2024):
  • 26.7.25.3 Class template adjacent_view::iterator [range.adjacent.iterator]

[edit] See also