lazy_split_view (Clase, Biblioteca estándar de C++)

Divide un intervalo en subrangos en función de un delimitador. El delimitador puede ser un único elemento o una vista de elementos. El delimitador no forma parte de los subrangos resultantes.

Las principales diferencias entre a split_view y son lazy_split_view :

Vista	Puede dividir un const intervalo	tipo de intervalo
split_view	no	Admite forward_range o superior.
lazy_split_view	sí	Admite input_range o superior.

Lo que hace que un lazy_split_view "diferido" es que no busca cabeza para el siguiente delimitador. Esto significa que puede admitir input_range , mientras split_view que requiere al menos forward_range. Esto se debe a input_range que es de un solo paso, mientras que forward_range permite la iteración de varios pasos.

Prefiere split_view porque es más eficaz, a menos que deba dividir un rango que sea const. Con respecto al rendimiento, split_view es más eficaz.

Tiene lazy_split_view un incremento de iterador menos eficaz y una comparación que split_view, pero sigue siendo O(1). Tiene split_view un mejor rendimiento cuando la distancia entre delimitadores es lo suficientemente pequeña para que los subrangos se ajusten a la memoria caché de CPU, en cuyo caso el lookahead delimitador almacena en caché de forma eficaz el siguiente subrango.

Sintaxis

template<input_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
    indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to> &&
    (forward_range<V> || tiny_range<Pattern>)
class lazy_split_view : public view_interface<lazy_split_view<V, Pattern>>

Parámetros de plantilla

Pattern
Tipo de la vista que especifica una secuencia delimitador.
El (forward_range<V> || tiny-range <Pattern>) requisito significa que cuando el intervalo subyacente no forward_rangees , el delimitador debe ser .tiny_range Un tiny_range es un intervalo con extensión estática cuyo tamaño es 0 o 1. tiny_range<T> requiere sized_range<T>, y T::size() debe ser una expresión constante menor o igual que 1.

V
Tipo de la vista subyacente.

Características

Para obtener una descripción de las siguientes entradas, vea View class characteristics (Ver características de clase).

Adaptador de intervalo: lazy_splitintervalo subyacente: debe satisfacer input_range o una categoría superior del iterador de vista: igual que el tipo de elemento del intervalo subyacente: colección de range_reference_t<V>Tamaño: sin intervalo común: Sí cuando el intervalo subyacente es y .forward_range common Intervalo prestado: no es const-iterable: solo si el intervalo subyacente cumple forward_range y es const-iterable

Miembros

Funciones miembro	Descripción
Constructores	Construya la vista.
baseC++20	Obtenga el intervalo subyacente.
beginC++20	Obtenga un iterador al primer elemento de la vista.
endC++20	Obtenga el sentinel al final de la vista.
Heredado de view_interface	Descripción
emptyC++20	Compruebe si la vista está vacía.
frontC++20	Obtiene el primer elemento.
operator boolC++20	Compruebe si la vista no está vacía.

Requisitos

Encabezado: <ranges> (desde C++20)

Espacio de nombres: std::ranges

Opción del compilador: /std:c++20 o posterior es necesaria.

Constructores

Construcción de una instancia de lazy_split_view

1) lazy_split_view() = default;
2) constexpr lazy_split_view(V base, Pattern pattern);
3) template<input_range R> requires constructible_from<V, views::all_t<R>> && 
        constructible_from<Pattern, single_view<range_value_t<R>>>
        constexpr lazy_split_view(R&& rg, range_value_t<R> e);

Parámetros de plantilla

Pattern
Tipo del delimitador.

R
Tipo del rango.

V
Tipo de la vista subyacente.

Parámetros

e Elemento único que identifica dónde dividir la vista. El elemento no forma parte de los subrangos resultantes.

base
Vista subyacente.

pattern
Vista de elementos que identifica dónde dividir la vista. La vista de los elementos no forma parte de los subrangos resultantes.

rg
Intervalo que se va a dividir.

Valor devuelto

Instancia lazy_split_view de que contiene uno o varios subranges.

Comentarios

La mejor manera de crear un lazy_split_view es usar el adaptador de views::lazy_split rango. Los adaptadores de rango son la manera prevista de crear clases de vista. Los tipos de vista solo se exponen en caso de que desee crear su propio tipo de vista personalizado.

1) Cree un objeto lazy_split_view que no tenga elementos. La vista subyacente se construye de forma predeterminada. base() devuelve una copia de V().
2) Cree un lazy_split_view mediante la división de la vista mediante una secuencia de delimitador.
3) Cree un lazy_split_view mediante la división de la vista mediante un elemento delimitador.

Ejemplo: lazy_split_view

// requires /std:c++20 or later
#include <ranges>
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> rg{ 1, 2, 3, 1, 2, 3, 4, 5, 6 };

    // pipe syntax using range adaptor
    for (const auto& subrange : rg | std::views::split(3))
    {
        // Outputs:
        // 1 2
        // 1 2
        // 4 5 6
        for (const auto& elem : subrange)
        {
            std::cout << elem << ' ';
        }
        std::cout << '\n';
    }

    int delimiters[] = {2, 3};
    for (auto splitRange : std::views::split(rg, delimiters)) // ctor syntax
    {
        // outputs 1 1 4 5 6
        for (auto& i : splitRange)
        {
            std::cout << i << " ";
        }
    }
}

1 2
1 2
4 5 6
1 1 4 5 6

base

Obtiene una copia de la vista subyacente.

// Uses a copy constructor to return the underlying view
1) constexpr V base() const & requires std::copy_constructible<V>;

// Uses a move constructor to return the underlying view
2) constexpr V base() &&;

Parámetros

Ninguno.

Devoluciones

Vista subyacente.

begin

Obtenga un iterador al primer elemento de la vista.

constexpr auto begin();
constexpr auto begin() const requires forward_range<V> && forward_range<const V>

Parámetros

Ninguno.

Valor devuelto

Iterador que apunta al primer elemento de la vista.

end

Obtenga el sentinel al final de la vista.

1) constexpr auto end() const;
2) constexpr auto end() requires forward_range<V> && common_range<V>;

Parámetros

Ninguno.

Valor devuelto

Sentinel que sigue al último elemento de la vista:

Comentarios

2) El forward_range<V> requisito significa que la vista V tiene al menos un iterador hacia delante. Para obtener más información sobre los iteradores de rango, vea Ver características de clase. El common_range<V> requisito significa que la vista V tiene tipos de iterador y centinela idénticos.

Consulte también

<ranges>
lazy_split clase de adaptador desplit_view rango
ver clases