std::ranges::adjacent_view<V,N>::iterator
De es.cppreference.net
template< bool Const >
class /*iterator*/
|
(since C++23) (solo exposición*) |
|
El tipo de retorno de adjacent_view::begin, y de adjacent_view::end cuando la vista subyacente V es un common_range.
El tipo /*iterator*/<true> es devuelto por las sobrecargas calificadas como const. El tipo /*iterator*/<false> es devuelto por las sobrecargas no calificadas como const.
Tipos miembro
| Miembro | Definición |
Base (privado)
|
maybe-const <Const, V>(tipo miembro solo de exposición*) |
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>
|
Miembros de datos
| Miembro | Descripción |
std::array<ranges::iterator_t<Base>, N> current_ (privado)
|
un array de iteradores (objeto miembro de solo exposición*) |
Funciones miembro
|
construye un iterador
(función miembro pública) |
|
|
accede al elemento
(función miembro pública) |
|
|
accede a un elemento por índice
(función miembro pública) |
|
|
avanza o decrementa los iteradores subyacentes
(función miembro pública) |
Funciones no miembro
|
compara los iteradores subyacentes
(función) |
|
|
(C++23)
|
realiza aritmética de iteradores
(función) |
|
(C++23)
|
convierte el resultado de desreferenciar el iterador subyacente a su tipo de referencia de valor r asociado
(función) |
|
(C++23)
|
intercambia los objetos apuntados por dos iteradores subyacentes
(función) |
Ejemplo
Ejecutar este código
#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>); // algunos de los operadores disponibles: ++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; // modifica v[1] mediante el iterador 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--; // algunos de los operadores disponibles // j += 2; j -= 2; // error: estos operadores no están disponibles // std::ignore() = j[1]; // para iteradores bidireccionales }
Referencias
- Estándar C++23 (ISO/IEC 14882:2024):
-
- 26.7.25.3 Plantilla de clase adjacent_view::iterator [range.adjacent.iterator]