std::ranges::filter_view<V,Pred>::iterator

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de rangos

Acceso a rangos begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata empty

Conversiones de rangos std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Manejo de iteradores pendientes dangling borrowed_iterator_t borrowed_subrange_t

Primitivas de rangos
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Conceptos de rangos
range borrowed_range    sized_range	common_range view viewable_range	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	constant_range (C++23)

Vistas
view_interface	subrange

Fábricas de rangos
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Adaptadores de rangos
views::all_tviews::all ref_view owning_view as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while concat_viewviews::concat (C++26)(C++26) views::counted	drop_viewviews::drop drop_while_viewviews::drop_while join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   lazy_split_viewviews::lazy_split split_viewviews::split common_viewviews::common cache_latest_viewviews::cache_latest (C++26)(C++26)	reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Generadores de rangos std::generator (C++23)

Objetos cierre adaptadores de rangos range_adaptor_closure (C++23)

Objetos adaptadores de rangos

Elementos auxiliares
copyable-box movable-box (hasta C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::filter_view

Funciones miembro

filter_view::filter_view (C++20)

filter_view::base (C++20)

filter_view::pred (C++20)

filter_view::begin (C++20)

filter_view::end (C++20)

Guías de deducción (C++20)

Iterador

filter_view::iterator::iterator (C++20)

filter_view::iterator::base (C++20)

filter_view::iterator::operator*filter_view::iterator::operator-> (C++20)(C++20)

filter_view::iterator::operator++ filter_view::iterator::operator++(int) (C++20)(C++20)

filter_view::iterator::operator-- filter_view::iterator::operator--(int) (C++20)(C++20)

operator==(filter_view::iterator) (C++20)

iter_move(filter_view::iterator) (C++20)

iter_swap(filter_view::iterator) (C++20)

Centinela

filter_view::sentinel::sentinel (C++20)

filter_view::sentinel::base (C++20)

operator==(filter_view::iterator, filter_view::sentinel) (C++20)

 

<tbody> </tbody>

class /*iterator*/;		(desde C++20)

See More

El tipo de retorno de filter_view::begin. El nombre iterator es solo para efectos de exposición.

Es un bidirectional_iterator si V modela bidirectional_range, un forward_iterator si V modela forward_range, y input_iterator de lo contrario.

Se permite la modificación del elemento indicado por este iterador, pero da como resultado un comportamiento no definido si el valor resultante no satisface el predicado del filtro.

Tipos miembro

Tipo miembro	Definición
iterator_concept	std::bidirectional_iterator_tag, si V modela bidirectional_range, std::forward_iterator_tag, si V modela forward_iterator, std::input_iterator_tag de lo contrario.
iterator_category	Definido si y solo si V modela forward_range. Sea C el tipo std::iterator_traits<ranges::iterator_t<V>>::iterator_category. std::bidirectional_iterator_tag, si C modela std::derived_from<std::bidirectional_iterator_tag>, std::forward_iterator_tag, si C modela std::derived_from<std::forward_iterator_tag>, C de lo contrario.
value_type	ranges::range_value_t<V>
difference_type	ranges::range_difference_t<V>

Datos miembro

Las implementaciones típicas de iterator mantienen dos datos miembro no estáticos:

• un iterador de tipo ranges::iterator_t<V> en la vista (view) subyacente (que se muestra aquí como current_ solo de exposición), y
• un puntero de tipo ranges::filter_view<V, Pred>* al objeto filter_view padre (que se muestra aquí como parent_ solo de exposición).

Funciones miembro

(constructor) (C++20)	Construye un iterador. (función miembro pública)
base (C++20)	Devuelve el iterador subyacente. (función miembro pública)
operator*operator-> (C++20)	Reenvía al iterador subyacente. (función miembro pública)
operator++operator++(int)operator--operator--(int) (C++20)	Avanza o decrementa el iterador. (función miembro pública)

std::ranges::filter_view::iterator::iterator

<tbody> </tbody>

/*iterator*/() requires std::default_initializable<ranges::iterator_t<V>> = default;	(1)	(desde C++20)
constexpr /*iterator*/( filter_view& parent, ranges::iterator_t<V> current );	(2)	(desde C++20)

1) Inicializa current_ y parent_ con sus inicializadores de miembro por defecto, que son = ranges::iterator_t<V>() y = nullptr, respectivamente.

2) Inicializa current_ con std::move(current) y parent_ con std::addressof(parent).

std::ranges::filter_view::iterator::base

<tbody> </tbody>

constexpr const ranges::iterator_t<V>& base() const & noexcept;	(1)	(desde C++20)
constexpr ranges::iterator_t<V> base() &&;	(2)	(desde C++20)

1) Equivalente a return current_;.

2) Equivalente a return std::move(current_);.

std::ranges::filter_view::iterator::operator*,->

<tbody> </tbody>

constexpr ranges::range_reference_t<V> operator*() const;	(1)	(desde C++20)
constexpr ranges::iterator_t<V> operator->() const requires /*tiene-flecha*/<ranges::iterator_t<V>> && std::copyable<ranges::iterator_t<V>>;	(2)	(desde C++20)

1) Equivalente a return *current_;.

2) Equivalente a return current_;.
Para un tipo I, /*tiene-flecha*/<I> se modela o se satisface si y solo si I modela o satisface input_iterator, respectivamente, y ya sea que I es un tipo puntero o requires(I i){ i.operator->(); } es true.

std::ranges::filter_view::iterator::operator++

<tbody> </tbody>

constexpr /*iterator*/& operator++();	(1)	(desde C++20)
constexpr void operator++( int );	(2)	(desde C++20)
constexpr /*iterator*/ operator++( int ) requires ranges::forward_range<V>;	(3)	(desde C++20)

1) Equivalente a
current_ = ranges::find_if(std::move(++current_), ranges::end(parent_->base_), std::ref(*parent_->pred_)); return *this;.

2) Equivalente a ++*this;.

3) Equivalente a auto tmp = *this; ++*this; return tmp;.

std::ranges::filter_view::iterator::operator--

<tbody> </tbody>

constexpr /*iterator*/& operator--() requires ranges::bidirectional_range<V>;	(1)	(desde C++20)
constexpr /*iterator*/ operator--( int ) requires ranges::bidirectional_range<V>;	(2)	(desde C++20)

1) Equivalente a
do --current_; while (!std::invoke(*parent_->pred_, *current_)); return *this;.

2) Equivalente a auto tmp = *this; --*this; return tmp;.

Funciones no miembro

operator== (C++20)	Compara los iteradores subyacentes. (función)
iter_move (C++20)	Convierte el resultado de desreferenciar el iterador subyacente a su tipo referencia r-valor asociado. (función)
iter_swap (C++20)	Intercambia los objetos a los que apuntan los dos iteradores subyacentes. (función)

operator==(std::ranges::filter_view::iterator)

<tbody> </tbody>

friend constexpr bool operator==( const /*iterator*/& x, const /*iterator*/& y ) requires std::equality_comparable<ranges::iterator_t<V>>;		(desde C++20)

Equivalente a return x.current_ == y.current_;.

El operador != se sintetiza a partir de operator==.

Esta función no es visible a una búsqueda no calificada o calificada, y puede encontrarse solamente mediante la búsqueda dependiente de argumento cuando std::ranges::filter_view::iterator es una clase asociada de los argumentos.

iter_move(std::ranges::filter_view::iterator)

<tbody> </tbody>

friend constexpr ranges::range_rvalue_reference_t<V> iter_move( const /*iterator*/& i ) noexcept(noexcept(ranges::iter_move(i.current_)));		(desde C++20)

Equivalente a return ranges::iter_move(i.current_);.

Esta función no es visible a una búsqueda no calificada o calificada, y puede encontrarse solamente mediante la búsqueda dependiente de argumento cuando std::ranges::filter_view::iterator es una clase asociada de los argumentos.

iter_swap(std::ranges::filter_view::iterator)

<tbody> </tbody>

friend constexpr void iter_swap( const /*iterator*/& x, const /*iterator*/& y ) noexcept(noexcept(ranges::iter_swap(x.current_, y.current_))) requires std::indirectly_swappable<ranges::iterator_t<V>>;		(desde C++20)

Equivalente a ranges::iter_swap(x.current_, y.current_).

Esta función no es visible a una búsqueda no calificada o calificada, y puede encontrarse solamente mediante la búsqueda dependiente de argumento cuando std::ranges::filter_view::iterator es una clase asociada de los argumentos.

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
P2259R1	C++20	El tipo miembro iterator_category siempre estaba definido.	Definido solo si V es un forward_range.
LWG 3533	C++20	La sobrecarga const& de base copiaba el iterador subyacente.	Devuelve una referencia a él.
LWG 3593	C++20	La sobrecarga const& de base podría no ser noexcept.	Se hizo noexcept.