lazy_split_view classe (libreria standard C++)

Suddivide un intervallo in intervalli secondari in base a un delimitatore. Il delimitatore può essere un singolo elemento o una visualizzazione di elementi. Il delimitatore non fa parte degli intervalli secondari risultanti.

Le principali differenze tra un e un split_view lazy_split_view sono:

Visualizza	Può dividere un const intervallo	tipo di intervallo
split_view	no	Supporta forward_range o versione successiva.
lazy_split_view	yes	Supporta input_range o versione successiva.

Ciò che rende un lazy_split_view "lazy" è che non cerca il delimitatore successivo. Ciò significa che può supportare input_range mentre split_view richiede almeno forward_range. Ciò è dovuto al fatto che input_range è a passaggio singolo, mentre forward_range consente l'iterazione a più passaggi.

Preferisce split_view perché è più efficiente, a meno che non sia necessario dividere un intervallo che sia const. Per quanto riguarda le prestazioni, split_view è più efficiente.

Un lazy_split_view oggetto ha un incremento dell'iteratore meno efficiente e un confronto rispetto split_viewa , ma è ancora O(1). Un split_view ha prestazioni migliori quando la distanza tra delimitatori è sufficientemente piccola per gli intervalli secondari da adattarsi alla cache della CPU, nel qual caso la ricerca del delimitatore pre-memorizza nella cache il successivo intervallo secondario.

Sintassi

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

Parametri del modello

Pattern
Tipo della vista che specifica una sequenza di delimitatori.
Il (forward_range<V> || tiny-range <Pattern>) requisito significa che quando l'intervallo sottostante non forward_rangeè , il delimitatore deve essere .tiny_range Un tiny_range è un intervallo con extent statico la cui dimensione è 0 o 1. tiny_range<T> richiede sized_range<T>e T::size() deve essere un'espressione costante minore o uguale a 1.

V
Tipo della vista sottostante.

Caratteristiche

Per una descrizione delle voci seguenti, vedere Visualizzare le caratteristiche della classe

Adattatore di intervallo: lazy_splitl'intervallo sottostante: deve soddisfare input_range o una categoria di iteratore di visualizzazione superiore: uguale al tipo di elemento dell'intervallo sottostante: raccolta dirange_reference_t<V> dimensioni: nessun intervallo comune: Sì quando l'intervallo sottostante è sia forward_range e .common Intervallo preso in prestito: non è iterabile: solo se l'intervallo sottostante soddisfa forward_range e è constiterabile const

Membri

Funzioni membro	Descrizione
Costruttori	Costruisci la vista.
baseC++20	Ottenere l'intervallo sottostante.
beginC++20	Ottiene un iteratore al primo elemento nella visualizzazione.
endC++20	Ottenere l'sentinel alla fine della visualizzazione.
Ereditato da view_interface	Descrizione
emptyC++20	Verificare se la visualizzazione è vuota.
frontC++20	Ottenere il primo elemento.
operator boolC++20	Verificare se la visualizzazione non è vuota.

Requisiti

Intestazione: <ranges> (da C++20)

Spazio dei nomi: std::ranges

Opzione del compilatore: /std:c++20 o versione successiva è obbligatoria.

Costruttori

Costruire un'istanza di un oggetto 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);

Parametri del modello

Pattern
Tipo del delimitatore.

R
Tipo dell'intervallo.

V
Tipo della vista sottostante.

Parametri

e Singolo elemento che identifica dove dividere la visualizzazione. L'elemento non fa parte degli intervalli secondari risultanti.

base
Visualizzazione sottostante.

pattern
Visualizzazione degli elementi che identificano dove dividere la visualizzazione. La visualizzazione degli elementi non fa parte degli intervalli secondari risultanti.

rg
Intervallo da dividere.

Valore restituito

lazy_split_view Istanza che contiene uno o più subrangeoggetti .

Osservazioni:

Il modo migliore per creare un lazy_split_view oggetto consiste nell'usare l'adattatore views::lazy_split di intervallo. Gli adattatori di intervallo sono il modo previsto per creare classi di visualizzazione. I tipi di visualizzazione vengono esposti solo nel caso in cui si voglia creare un tipo di visualizzazione personalizzato.

1) Creare un oggetto lazy_split_view senza elementi. La vista sottostante è costruita per impostazione predefinita. base() restituisce una copia di V().
2) Creare un lazy_split_view oggetto suddividendo la vista usando una sequenza di delimitatori.
3) Creare un lazy_split_view oggetto suddividendo la vista usando un elemento delimitatore.

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

Ottiene una copia della visualizzazione sottostante.

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

Parametri

Nessuna.

Valori restituiti

Visualizzazione sottostante.

begin

Ottiene un iteratore al primo elemento nella visualizzazione.

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

Parametri

Nessuna.

Valore restituito

Iteratore che punta al primo elemento della visualizzazione.

end

Ottenere l'sentinel alla fine della visualizzazione.

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

Parametri

Nessuna.

Valore restituito

Sentinel che segue l'ultimo elemento nella visualizzazione:

Osservazioni:

2) Il forward_range<V> requisito indica che la vista V ha almeno un iteratore in avanti. Per altre informazioni sugli iteratori di intervallo, vedere Visualizzare le caratteristiche della classe. Il common_range<V> requisito indica che la vista V ha tipi iteratori e sentinel identici.

Vedi anche

<ranges>
lazy_splitClasse dell'adattatore di intervallosplit_view
classi di visualizzazione