Namespaces
Variants

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

    De es.cppreference.net
     
    C++
    Soporte del compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades 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 soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de rangos
    Adaptadores de rango
     
    std::ranges::lazy_split_view
     
    template< bool Const >
struct /*outer_iterator*/;
    		(desde C++20)
    (solo exposición*)

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

    Si V o Pattern no es una simple view (p. ej., si ranges::iterator_t<const V> no es válida o es diferente de ranges::iterator_t<V>), Const es true para iteradores devueltos desde las sobrecargas const, y false en caso contrario. Si V es una simple view, Const es true si y solo si V es una forward_range.

    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 por valor los miembros de datos no estáticos con su inicializador de miembro por defecto, 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 por defecto a false.

    std::ranges::lazy_split_view::outer_iterator ::operator*

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

    Equivalente a return value_type{*this};.

    std::ranges::lazy_split_view::outer_iterator ::operator++

    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; // The pattern matched; skip it
        }
    } while (++/*cur*/() != end);
}
return *this;
    2) Equivalente a 
    if constexpr (ranges::forward_range<Base>)
{
    auto tmp = *this;
    ++*this;
    return tmp;
}
else
{
    ++*this; // no return statement
}

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

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

    Esta función miembro de conveniencia es referida desde /*outer_iterator*/::operator++(), desde la función 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