std::ranges::adjacent_view<V,N>::iterator
From cppreference.com
< cpp | ranges | adjacent view
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] Non-member functions
compares the underlying iterators (function) | |
(C++23) |
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
Run this code
#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]