lazy_split_view Klasse (C++-Standardbibliothek)

Teilt einen Bereich basierend auf einem Trennzeichen in Unterbereiche auf. Das Trennzeichen kann ein einzelnes Element oder eine Ansicht von Elementen sein. Das Trennzeichen ist nicht Teil der resultierenden Unterbereiche.

Die hauptunterschiede zwischen a split_view und a lazy_split_view sind:

Was einen lazy_split_view "faulen" macht, ist, dass es nicht nach dem nächsten Trennzeichen sucht. Dies bedeutet, dass sie unterstützt werden input_range kann, während split_view mindestens forward_rangeerforderlich ist. Dies liegt daran, dass input_range es sich um einen einfachen Durchlauf handelt, während forward_range die Iteration mit mehreren Durchläufen möglich ist.

Bevorzugen Sie split_view es, da sie effizienter ist – es sei denn, Sie müssen einen Bereich teilen, der lautet const. Was die Leistung betrifft, split_view ist effizienter.

Ein lazy_split_view Iterator hat weniger effizientes Iterator-Inkrement und Vergleich als split_view, ist aber immer noch O(1). Eine split_view bessere Leistung, wenn der Abstand zwischen Trennzeichen klein genug ist, damit Unterranges in den CPU-Cache passen. In diesem Fall speichert das Trennzeichen-Lookahead effektiv den nächsten Unterbereich vor.

Syntax

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

Vorlagenparameter

Pattern
Der Typ der Ansicht, die eine Trennzeichensequenz angibt.
Die (forward_range<V> || tiny-range <Pattern>) Anforderung bedeutet, dass es sich bei dem zugrunde liegenden Bereich nicht forward_rangeum ein tiny_rangeTrennzeichen handelt. A tiny_range ist ein Bereich mit statischem Ausmaß, dessen Größe 0 oder 1 ist. tiny_range<T> erfordert sized_range<T>und T::size() muss ein Konstantenausdruck sein, der kleiner als oder gleich 1 ist.

V
Der Typ der zugrunde liegenden Ansicht.

Merkmale

Eine Beschreibung der folgenden Einträge finden Sie unter Anzeigen von Klassenmerkmalen

Range adaptor: Underlying range: lazy_splitmust satisfy input_range or higher View iterator category: same as the underlying range Element type: collection of range_reference_t<V>Size: no Common range: Yes when the underlying range is both forward_range and .common Geliehener Bereich: kein Is const-iterable: nur, wenn der zugrunde liegende Bereich erfüllt forward_range ist und -iterierbar ist const

Member

Anforderungen

Header: <ranges> (seit C++20)

Namespace:std::ranges

Compileroption: /std:c++20 oder höher ist erforderlich.

Konstruktoren

Erstellen einer Instanz einer 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);

Vorlagenparameter

Pattern
Der Typ des Trennzeichens.

R
Der Typ des Bereichs.

V
Der Typ der zugrunde liegenden Ansicht.

Parameter

e Ein einzelnes Element, das angibt, wo die Ansicht geteilt werden soll. Das Element ist nicht Teil der resultierenden Unterbereiche.

base
Die zugrunde liegende Ansicht.

pattern
Die Ansicht der Elemente, die angibt, wo die Ansicht geteilt werden soll. Die Ansicht der Elemente ist nicht Teil der resultierenden Unterbereiche.

rg
Der bereich, der geteilt werden soll.

Rückgabewert

Eine lazy_split_view Instanz, die mindestens eine subrangeInstanz enthält.

Hinweise

Die beste Methode zum Erstellen eines Steuerelements lazy_split_view ist die Verwendung des views::lazy_split Bereichsadapters. Bereichsadapter sind die beabsichtigte Möglichkeit zum Erstellen von Ansichtsklassen. Die Ansichtstypen werden nur für den Fall verfügbar gemacht, dass Sie ihren eigenen benutzerdefinierten Ansichtstyp erstellen möchten.

1) Erstellen Sie ein lazy_split_view Element ohne Elemente. Die zugrunde liegende Ansicht wird standardmäßig erstellt. base() gibt eine Kopie von V().
2) Erstellen Sie eine lazy_split_view durch Teilen der Ansicht mithilfe einer Trennzeichensequenz.
3) Erstellen Sie eine lazy_split_view durch Teilen der Ansicht mithilfe eines Trennzeichenelements.

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

Ruft eine Kopie der zugrunde liegenden Ansicht ab.

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

Parameter

Keine.

Gibt zurück

Die zugrunde liegende Ansicht.

begin

Rufen Sie einen Iterator zum ersten Element in der Ansicht ab.

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

Parameter

Keine

Rückgabewert

Ein Iterator, der auf das erste Element in der Ansicht zeigt.

end

Rufen Sie den Sentinel am Ende der Ansicht ab.

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

Parameter

Keine

Rückgabewert

Der Sentinel, der auf das letzte Element in der Ansicht folgt:

Hinweise

2) Die forward_range<V> Anforderung bedeutet, dass die Ansicht V mindestens über einen Vorwärts iterator verfügt. Weitere Informationen zu Bereichs iteratoren finden Sie unter Eigenschaften der Ansichtsklasse. Die common_range<V> Anforderung bedeutet, dass die Ansicht V identische Iterator- und Sentineltypen aufweist.

Siehe auch

<ranges>
lazy_splitRange Adaptor-Klassesplit_view
Anzeigen von Klassen