Classe lazy_split_view (Biblioteca Padrão C++)

Divide um intervalo em subintervalos com base em um delimitador. O delimitador pode ser um único elemento ou uma visualização de elementos. O delimitador não faz parte dos subintervalos resultantes.

As principais diferenças entre a split_view e a lazy_split_view são:

Exibir	Pode dividir um const intervalo	Tipo de intervalo
split_view	não	Suportes forward_range ou superior.
lazy_split_view	sim	Suportes input_range ou superior.

O que torna um lazy_split_view "preguiçoso" é que ele não procura o próximo delimitador. Isso significa que ele pode suportar input_range , enquanto split_view requer pelo menos forward_range. Isso ocorre porque input_range é de passagem única, enquanto forward_range permite a iteração de várias passagens.

Prefira split_view porque é mais eficiente - a menos que você deva dividir um intervalo que seja const. Em relação ao desempenho, split_view é mais eficiente.

A lazy_split_view tem incremento e comparação de iterador menos eficientes do que split_view, mas ainda é O(1). A split_view tem melhor desempenho quando a distância entre os delimitadores é pequena o suficiente para que os subintervalos caibam no cache da CPU, caso em que o delimitador lookahead pré-armazena efetivamente o próximo subintervalo.

Sintaxe

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 modelo

Pattern
O tipo da exibição que especifica uma sequência de delimitadores.
O (forward_range<V> || tiny-range <Pattern>) requisito significa que, quando o intervalo subjacente não forward_rangeé , o delimitador deve ser um tiny_range. A tiny_range é um intervalo com extensão estática cujo tamanho é 0 ou 1. tiny_range<T> requires sized_range<T>, e T::size() deve ser uma expressão constante menor ou igual a 1.

V
O tipo da exibição subjacente.

Características

Para obter uma descrição das entradas a seguir, consulte Exibir características da classe

Adaptador de intervalo:lazy_split Intervalo subjacente: deve satisfazer input_range ou superior Exibir categoria do iterador: igual ao intervalo subjacente Tipo de elemento: coleção de range_reference_t<V>Dimensionado: não Intervalo comum: Sim quando o intervalo subjacente é ambos e forward_range common. Intervalo emprestado: no É const-iterável: somente se o intervalo subjacente satisfizer forward_range e for const-iterável

Membros

Funções de membro	Descrição
Construtores	Construa a exibição.
baseC++20	Obtenha o intervalo subjacente.
beginC++20	Obtenha um iterador para o primeiro elemento na exibição.
endC++20	Pegue a sentinela no final da vista.
Herdado de view_interface	Descrição
emptyC++20	Teste se a exibição está vazia.
frontC++20	Obtenha o primeiro elemento.
operator boolC++20	Teste se a exibição não está vazia.

Requisitos

Cabeçalho: <ranges> (desde C++20)

Namespace: std::ranges

Opção do compilador: /std:c++20 ou posterior é necessária.

Construtores

Construir uma instância de um 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 modelo

Pattern
O tipo do delimitador.

R
O tipo do intervalo.

V
O tipo da exibição subjacente.

Parâmetros

e Um único elemento que identifica onde dividir a exibição. O elemento não faz parte dos subintervalos resultantes.

base
A visão subjacente.

pattern
A exibição de elementos que identifica onde dividir a exibição. A exibição de elementos não faz parte dos subintervalos resultantes.

rg
O intervalo a ser dividido.

Valor retornado

Uma lazy_split_view instância que contém um ou mais subranges.

Comentários

A melhor maneira de criar um lazy_split_view é usando o adaptador de views::lazy_split intervalo. Os adaptadores de intervalo são a maneira pretendida de criar classes de exibição. Os tipos de exibição são expostos apenas caso você queira criar seu próprio tipo de exibição personalizado.

1) Crie um lazy_split_view que não tenha elementos. A exibição subjacente é construída por padrão. base() retorna uma cópia do V().
2) Crie um lazy_split_view dividindo a visualização usando uma sequência delimitadora.
3) Crie um lazy_split_view dividindo a visualização usando um elemento delimitador.

Exemplo: 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

Obtém uma cópia da exibição subjacente.

// 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

Nenhum.

Devoluções

A visão subjacente.

begin

Obtenha um iterador para o primeiro elemento na exibição.

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

Parâmetros

Nenhum.

Valor retornado

Um iterador apontando para o primeiro elemento na exibição.

end

Pegue a sentinela no final da vista.

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

Parâmetros

Nenhum.

Valor retornado

A sentinela que segue o último elemento na exibição:

Comentários

2) O forward_range<V> requisito significa que a exibição V tem pelo menos um iterador de encaminhamento. Para obter mais informações sobre iteradores de intervalo, consulte Exibir características da classe. O common_range<V> requisito significa que a exibição V tem tipos idênticos de iterador e sentinela.

Confira também

<ranges>
lazy_split classe dosplit_view adaptador de alcance
Ver aulas