Namespaces
Variants

std::ranges:: lazy_split_view<V, Pattern>:: outer_iterator

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::lazy_split_view
template < bool Const >
struct /*outer_iterator*/ ;
(desde C++20)
( solo para exposición* )

El tipo de retorno de lazy_split_view::begin , y de lazy_split_view::end cuando la vista subyacente es un common_range y un forward_range .

Si ni V ni Pattern son una vista simple (por ejemplo, si ranges:: iterator_t < const V > no es válido o difiere de ranges:: iterator_t < V > ), Const es true para los iteradores devueltos por las sobrecargas const, y false en caso contrario. Si V es una vista simple, Const es true si y solo si V es un forward_range .

Contenidos

Tipos de miembros

Miembro Definición
Parent maybe-const  < Const, ranges:: lazy_split_view >
( tipo de miembro solo para exposición* )
Base maybe-const  < Const, V >
( tipo de miembro solo para exposición* )
iterator_concept
iterator_category
(presente solo si Base modela forward_range ) 		std::input_iterator_tag
el tipo de valor del outer_iterator
(clase de miembro pública)
difference_type ranges:: range_difference_t < Base >

Miembros de datos

Miembro Descripción
Parent * parent_ (privado) un puntero al objeto padre lazy_split_view
( objeto miembro solo para exposición* )
ranges:: iterator_t < Base > current_ (privado)
(presente solo si V modela forward_range ) 		un iterador hacia la view subyacente
( objeto miembro solo para exposición* )
bool trailing_empty_ (privado) una bandera que indica si se alcanzó un subrango vacío final (si existe)
( objeto miembro solo para exposición* )

Funciones miembro

(constructor)
construye un iterador
(función miembro pública)
operator*
devuelve el subrango actual
(función miembro pública)
operator++ operator++ (int)
avanza el iterador
(función miembro pública)
cur
devuelve condicionalmente una referencia al current_ (si está presente) o al * parent_ - > current_
( función miembro solo para exposición* )

Funciones miembro

std::ranges::lazy_split_view:: outer_iterator :: outer_iterator

/*outer_iterator*/ ( ) = default ;
(1) (desde C++20)
constexpr explicit /*outer_iterator*/ ( Parent & parent )
requires ( ! ranges:: forward_range < Base > ) ;
(2) (desde C++20)
constexpr /*outer_iterator*/ ( Parent & parent,

ranges:: iterator_t < Base > current )

requires ranges:: forward_range < Base > ;
(3) (desde C++20)
constexpr /*outer_iterator*/ ( /*outer_iterator*/ < ! Const > i )

requires Const && std:: convertible_to < ranges:: iterator_t < V > ,

ranges:: iterator_t < Base >> ;
(4) (desde C++20)
1) Inicializa los miembros de datos no estáticos con su inicializador de miembro predeterminado, es decir:
  • parent_ = nullptr ; ,
  • current_ = iterator_t < Base > ( ) ; (presente solo si V modela forward_range ),
2) Inicializa parent_ con std:: addressof ( parent ) .
3) Inicializa parent_ con std:: addressof ( parent ) y current_ con std :: move ( current ) .
4) Inicializa parent_ con i. parent_ , current_ con std :: move ( i. current_ ) , y trailing_empty_ con t. trailing_empty_ .

El trailing_empty_ se inicializa con su inicializador de miembro predeterminado a false .

std::ranges::lazy_split_view:: outer_iterator :: operador*

constexpr value_type operator * ( ) const ;
(desde C++20)

Equivalente a return value_type { * this } ; .

std::ranges::lazy_split_view:: outer_iterator :: operador++

constexpr /*outer_iterator*/ & operator ++ ( ) ;
(1) (desde C++20)
constexpr decltype ( auto ) operator ++ ( int ) ;
(2) (desde C++20)
1) El cuerpo de la función es equivalente a 
const auto end = ranges::end(parent_->base_);
if (/*cur*/() == end)
{
    trailing_empty_ = false;
    return *this;
}
const auto [pbegin, pend] = ranges::subrange{parent_->pattern_};
if (pbegin == pend)
    ++/*cur*/();
else if constexpr (/*tiny_range*/<Pattern>)
{
    /*cur*/() = ranges::find(std::move(/*cur*/()), end, *pbegin);
    if (/*cur*/() != end)
    {
        ++/*cur*/();
        if (/*cur*/() == end)
            trailing_empty_ = true;
    }
}
else
{
    do
    {
        auto [b, p] = ranges::mismatch(/*cur*/(), end, pbegin, pend);
        if (p == pend)
        {
            /*cur*/() = b;
            if (/*cur*/() == end)
                trailing_empty_ = true;
            break; // El patrón coincidió; saltarlo
        }
    } while (++/*cur*/() != end);
}
return *this;
2) Equivalente a 
if constexpr (ranges::forward_range<Base>)
{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
{
    ++*this; // sin sentencia return
}

std::ranges::lazy_split_view:: outer_iterator :: cur ()

constexpr auto & /*cur*/ ( ) noexcept ;
(1) (desde C++20)
( solo para exposición* )
constexpr auto & /*cur*/ ( ) const noexcept ;
(2) (desde C++20)
( solo para exposición* )

Esta función miembro de conveniencia es referenciada desde /*outer_iterator*/ :: operator ++ ( ) , desde el no-miembro operator == ( const /*outer_iterator*/ & , std:: default_sentinel_t ) , y desde algunas funciones miembro de la posible implementación de inner_iterator .

1,2) Equivalente a 
if constexpr (ranges::forward_range<V>)
    return current_;
else
    return *parent->current_;

Funciones no miembro

operator==
(C++20)
compara los iteradores subyacentes o el iterador subyacente y std::default_sentinel
(función)

operator== (std::ranges::split_view:: outer_iterator )

friend constexpr bool operator == ( const /*outer_iterator*/ & x,

const /*outer_iterator*/ & y )

requires forward_range < Base > ;
(1) (desde C++20)
friend constexpr bool operator == ( const /*outer_iterator*/ & x,
std:: default_sentinel_t ) ;
(2) (desde C++20)
1) Equivalente a return x. current_ == y. current_ and x. trailing_empty_ == y. trailing_empty_ ; .
2) Equivalente a return x. /*cur*/ ( ) == ranges:: end ( x. parent_ - > base_ ) and ! x. trailing_empty_ ; .

El operador != es sintetizado a partir de operator== .

Estas funciones no son visibles para la búsqueda no calificada ordinaria o la búsqueda calificada , y solo pueden encontrarse mediante búsqueda dependiente de argumentos cuando std::ranges::split_view:: outer_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 publicados anteriormente de C++.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3904 C++20 trailing_empty_ no se inicializaba en el constructor ( 4 ) inicializado