Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::filter_view
class /*iterator*/ ;
(desde C++20)
( solo para exposición* )

El tipo de retorno de filter_view::begin .

Esto es un bidirectional_iterator si V modela bidirectional_range , un forward_iterator si V modela forward_range , y input_iterator en caso contrario.

Se permite la modificación del elemento denotado por este iterador, pero resulta en comportamiento indefinido si el valor resultante no satisface el predicado del filtro.

Contenidos

Tipos de miembros

Tipo Definición
iterator_concept
iterator_category
(presente solo si V modela
forward_range )

Sea C el tipo std:: iterator_traits < ranges:: iterator_t < V >> :: iterator_category .

value_type ranges:: range_value_t < V >
difference_type ranges:: range_difference_t < V >

Miembros de datos

Miembro Descripción
ranges:: iterator_t < V > current_ (privado) un iterador hacia la view subyacente
( objeto miembro solo para exposición* )
ranges:: filter_view < V, Pred > * parent_ (privado) un puntero al objeto filter_view padre
( objeto miembro solo para exposición* )

Funciones miembro

construye un iterador
(función miembro pública)
devuelve el iterador subyacente
(función miembro pública)
redirige al iterador subyacente
(función miembro pública)
avanza el iterador
(función miembro pública)
decrementa el iterador
(función miembro pública)

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

/*iterator*/ ( )
requires std:: default_initializable < ranges:: iterator_t < V >> = default ;
(1) (since C++20)
constexpr /*iterator*/ ( filter_view & parent,
ranges:: iterator_t < V > current ) ;
(2) (since 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

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*,->

constexpr ranges:: range_reference_t < V > operator * ( ) const ;
(1) (desde C++20)
constexpr ranges:: iterator_t < V > operator - > ( ) const

requiere /*has-arrow*/ < 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 , /*has-arrow*/ < I > se modela o satisface, si y solo si I modela o satisface input_iterator respectivamente, y ya sea que I sea un tipo puntero o que requiere ( I i ) { i. operator - > ( ) ; } sea true .

std::ranges::filter_view:: iterator :: operador++

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 :: operador--

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

(C++20)
compara los iteradores subyacentes
(función)
(C++20)
convierte el resultado de desreferenciar el iterador subyacente a su tipo de referencia de valor r asociado
(función)
(C++20)
intercambia los objetos apuntados por dos iteradores subyacentes
(función)

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

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 != es sintetizado a partir de operator== .

Esta función no es visible para la búsqueda no calificada ordinaria o la búsqueda calificada , y solo puede ser encontrada mediante búsqueda dependiente de argumentos cuando std::ranges::filter_view:: iterator es una clase asociada de los argumentos.

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

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 para la búsqueda no calificada ordinaria o la búsqueda calificada , y solo puede ser encontrada mediante búsqueda dependiente de argumentos cuando std::ranges::filter_view:: iterator es una clase asociada de los argumentos.

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

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 para la búsqueda no calificada o búsqueda calificada ordinaria, y solo puede ser encontrada mediante búsqueda dependiente de argumentos cuando std::ranges::filter_view:: iterator es una clase asociada de los argumentos.

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento 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 al mismo
LWG 3593 C++20 la sobrecarga const & de base podría no ser noexcept marcada como noexcept