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

Divide una vista 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 del objeto resultante split_view.

Una vista relacionada es la lazy_split_view clase . Las principales diferencias entre split_view y lazy_split_view son:

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.

Prefiere split_view porque es más eficaz a menos que deba dividir un intervalo que sea const.

Sintaxis

template<forward_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
    indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
class split_view : public view_interface<split_view<V, Pattern>>;

Parámetros de plantilla

Pattern
Tipo de la vista que especifica la secuencia delimitador.

V
Tipo de la vista subyacente.

Características de la vista

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

Característica	Descripción
Adaptador de rango	views::split
Intervalo subyacente	Igual que el intervalo subyacente
Tipo de elemento	range_reference_t<V>
Ver categoría de iterador	Satisface forward_range
Tamaño	No
Es const-iterable	No
Rango común	Solo si el intervalo subyacente cumple common_range
Intervalo prestado	No

Miembros

Funciones miembro	Descripción
Constructores	Construya la vista.
baseC++20	Obtenga el intervalo subyacente.
beginC++20	Obtenga un iterador al primer elemento.
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 split_view

1) split_view() requires default_initializable<V> && default_initializable<Pattern> = default;
2) constexpr 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 split_view(R&& rg, range_value_t<R> e);

Parámetros

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

base
Vista subyacente.

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

rg
Intervalo que se va a dividir.

Para obtener información sobre los tipos de parámetros de plantilla, consulte Parámetros de plantilla.

Valor devuelto

Instancia split_view de que contiene uno o varios subrangos.

Comentarios

La mejor manera de crear un split_view es usar el adaptador de views::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 split_view objeto construido de forma predeterminada. La vista subyacente y pattern se construyen de forma predeterminada. base() devuelve una copia de V().
2) Cree un split_view mediante la división de la vista mediante una secuencia de delimitadores.
3) Cree un split_view mediante la división de la vista mediante un único delimitador.

Por ejemplo, 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
    {
        for (auto& i : splitRange)
        {
            std::cout << i << " "; // 1 1 4 5 6
        }
    }
}

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();

Parámetros

Ninguno.

Valor devuelto

Iterador que apunta al primer elemento de la vista.

end

Obtenga el sentinel al final de la vista.

constexpr auto end();

Parámetros

Ninguno.

Valor devuelto

Sentinel que sigue al último elemento de la vista:

Consulte también

<ranges>
split_view adaptador de rango
Clase lazy_split_view
ver clases