lazy_split_view classe (bibliothèque standard C++)

Fractionne une plage en sous-plages en fonction d’un délimiteur. Le délimiteur peut être un élément unique ou une vue d’éléments. Le délimiteur ne fait pas partie des sous-plages résultantes.

Les principales différences entre a split_view et a lazy_split_view sont les suivantes :

Ce qui rend un lazy_split_view « paresseux » est qu’il ne regarde pas pour le délimiteur suivant. Cela signifie qu’il peut prendre en charge input_range alors que split_view nécessite au moins forward_range. Cela est dû au fait qu’il input_range s’agit d’une seule passe, tandis que forward_range l’itération multi-passe est activée.

Préférez split_view parce qu’il est plus efficace- sauf si vous devez fractionner une plage qui est const. En ce qui concerne les performances, split_view il est plus efficace.

Un lazy_split_view itérateur a moins efficace d’incrémentation et de comparaison que split_view, mais est toujours O(1). Une split_view meilleure performance lorsque la distance entre les délimiteurs est suffisamment petite pour que les sous-ranges s’intègrent dans le cache du processeur, auquel cas le lookahead délimiteur pré-cache efficacement la sous-plage suivante.

Syntaxe

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

Paramètres de modèle

Pattern
Type de la vue qui spécifie une séquence de délimiteur.
L’exigence (forward_range<V> || tiny-range <Pattern>) signifie que lorsque la plage sous-jacente n’est pas forward_range, le délimiteur doit être un tiny_range. Il tiny_range s’agit d’une plage dont la taille est de 0 ou 1. tiny_range<T> nécessite sized_range<T>, et T::size() doit être une expression constante inférieure ou égale à 1.

V
Type de la vue sous-jacente.

Caractéristiques

Pour obtenir une description des entrées suivantes, consultez les caractéristiques de classe View

Adaptateur de plage : lazy_splitplage sous-jacente : doit satisfaire ou une input_range catégorie d’itérateur d’affichage supérieure : identique au type d’élément de plage sous-jacent : collection derange_reference_t<V> Taille : aucune plage commune : Oui lorsque la plage sous-jacente est à la fois forward_range et common. Plage empruntée : pas d’itérable const: uniquement si la plage sous-jacente satisfait forward_range et est const-itérable

Membres

Spécifications

En-tête : <ranges> (depuis C++20)

Espace de noms : std::ranges

Option du compilateur : /std:c++20 ou version ultérieure est requise.

Constructeurs

Construire une instance d’un 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);

Paramètres de modèle

Pattern
Type du délimiteur.

R
Type de la plage.

V
Type de la vue sous-jacente.

Paramètres

e Élément unique qui identifie où fractionner la vue. L’élément ne fait pas partie des sous-plages résultantes.

base
Vue sous-jacente.

pattern
Vue des éléments qui identifient où fractionner la vue. La vue des éléments ne fait pas partie des sous-plages résultantes.

rg
Plage à fractionner.

Valeur retournée

Instance lazy_split_view qui contient un ou plusieurs subranges.

Notes

La meilleure façon de créer un lazy_split_view est d’utiliser l’adaptateur views::lazy_split de plage. Les adaptateurs de plage sont la méthode prévue pour créer des classes d’affichage. Les types d’affichage sont exposés uniquement si vous souhaitez créer votre propre type d’affichage personnalisé.

1) Créez un lazy_split_view élément qui n’a aucun élément. La vue sous-jacente est construite par défaut. base() retourne une copie de V().
2) Créez une lazy_split_view vue en fractionnant la vue à l’aide d’une séquence de délimiteur.
3) Créez un lazy_split_view en fractionnant la vue à l’aide d’un élément délimiteur.

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

Obtient une copie de la vue sous-jacente.

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

Paramètres

Aucune.

Retours

Vue sous-jacente.

begin

Obtenez un itérateur sur le premier élément de la vue.

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

Paramètres

Aucune.

Valeur retournée

Itérateur pointant vers le premier élément de la vue.

end

Obtenez la sentinelle à la fin de la vue.

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

Paramètres

Aucune.

Valeur retournée

Sentinel qui suit le dernier élément de la vue :

Notes

2) L’exigence forward_range<V> signifie que la vue V a au moins un itérateur avant. Pour plus d’informations sur les itérateurs de plage, consultez Les caractéristiques de classe View. L’exigence common_range<V> signifie que la vue V a des itérateurs et des types sentinel identiques.

Voir aussi

<ranges>
lazy_split classe d’adaptateursplit_view de plage
afficher les classes