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.
Characteristics
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. |
base C++20 |
Obtenha o intervalo subjacente. |
begin C++20 |
Obtenha um iterador para o primeiro elemento na exibição. |
end C++20 |
Pegue a sentinela no final da vista. |
Herdado de view_interface |
Descrição |
empty C++20 |
Teste se a exibição está vazia. |
front C++20 |
Obtenha o primeiro elemento. |
operator bool C++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 subrange
s.
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