std::ranges::views::lazy_split, std::ranges::lazy_split_view - cppreference.com

2) Objeto adaptador de rango. La expresión views::lazy_split(e, f) es equivalente en expresión a lazy_split_view(e, f).

3) El concepto solo de exposición /*rango_diminuto*/<Pattern> se satisface si Pattern satisface sized_range, Pattern::size() es una expresión constante y adecuada como un argumento de plantilla de no tipo, y el valor de Pattern::size() es menor que o igual a 1. Notablemente, empty_view y single_view satisfacen este concepto.

lazy_split_view modela los conceptos forward_range y input_range cuando la vista subyacente V modela los conceptos respectivos, y modela common_range cuando V modela tanto forward_range como common_range.

El rango interno (ranges::range_reference_t<lazy_split_view>) modela los conceptos forward_range y input_range cuando la vista subyacente V modela los conceptos respectivos. No modela common_range, y no puede usarse con algoritmos que esperan un bidirectional_range o más alto.

Datos miembro

Las implementaciones típicas de lazy_split_view mantienen dos o tres datos miembro no estáticos:

• la vista subyacente de tipo V (que se muestra aquí como base_ solo de exposición),
• el patrón (que se muestra aquí como pattern_ solo de exposición) que se utiliza como delimitador para dividir la vista subyacente, y
• el objeto almacenador en caché (que se muestra aquí como current_ solo de exposición) del tipo solo de exposición similar a std::optional /*no_propagador_de_caché*/<ranges::iterator_t<V>>. current_ almacena en caché el resultado de las llamadas a begin(). Está presente solo si V no satisface forward_range.

Funciones miembro

Clases anidadas

Guías de deducción

Notas

lazy_split_view se introdujo por el informe de defecto P2210R2 posterior a C++20. Tiene el mismo mecanismo perezoso que el de la vista split_view antigua antes del cambio.

Ejemplo

#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>

// P2210R2: un parche temporal hasta que se use g++ en línea >= 12
#define lazy_split_view split_view
#define lazy_split split

auto imprimir = [](auto const& view)
{
    // `view` es una vista std::views::lazy_split_view::/*outer_iterator*/::value_type

    for (std::cout << "{ "; const auto elemento : view)
        std::cout << elemento << ' ';
    std::cout << "} ";
};

int main()
{
    constexpr static auto fuente = { 0, 1,0, 2,3,0, 4,5,6,0, 7,8,9 };
    constexpr int delimitador {0};
    constexpr std::ranges::lazy_split_view vista_externa{fuente, delimitador};
    std::cout << "divisiones[" << std::ranges::distance(vista_externa) << "]:  ";
    for (auto const& vista_interna: vista_externa)
        imprimir(vista_interna);

    constexpr std::string_view hola { "Hola C++ 20 !" };
    std::cout << "\n" "subcadenas:     ";
    std::ranges::for_each(hola | std::views::lazy_split(' '), imprimir);

    constexpr std::string_view texto { "Hola-+-C++-+-20-+-!" };
    constexpr std::string_view delim { "-+-" };
    std::cout << "\n" "subcadenas: ";
    std::ranges::for_each(texto | std::views::lazy_split(delim), imprimir);
}

divisiones[5]:  { } { 1 } { 2 3 } { 4 5 6 } { 7 8 9 }
subcadenas:     { H o l a } { C + + } { 2 0 } { ! }
subcadenas:     { H o l a } { C + + } { 2 0 } { ! }

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

Véase también