split_view Klasse (C++-Standardbibliothek)

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

Eine verwandte Ansicht ist die lazy_split_view Klasse. Die wichtigsten Unterschiede zwischen split_view und lazy_split_view sind:

Ansicht	Kann einen const Bereich teilen	Bereichstyp
split_view	Nein	Unterstützt forward_range oder höher.
lazy_split_view	ja	Unterstützt input_range oder höher.

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

Syntax

template<forward_range V, forward_range Pattern>
    requires view<V> && view<Pattern> &&
    indirectly_comparable<iterator_t<V>, iterator_t<Pattern>, ranges::equal_to>
class split_view : public view_interface<split_view<V, Pattern>>;

Vorlagenparameter

Pattern
Der Typ der Ansicht, die die Trennzeichensequenz angibt.

V
Der Typ der zugrunde liegenden Ansicht.

Eigenschaften der Ansicht

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

Merkmal	Beschreibung
Range Adaptor	views::split
Zugrunde liegender Bereich	Identisch mit dem zugrunde liegenden Bereich
Elementtyp	range_reference_t<V>
Iteratorkategorie anzeigen	Erfüllt forward_range
Größer eingestellt	No
Ist const-iterierbar	No
Allgemeiner Bereich	Nur, wenn der zugrunde liegende Bereich erfüllt ist common_range
Geliehener Bereich	No

Member

Memberfunktionen	Beschreibung
Konstruktoren	Erstellen Sie die Ansicht.
baseC++20	Rufen Sie den zugrunde liegenden Bereich ab.
beginC++20	Rufen Sie einen Iterator zum ersten Element ab.
endC++20	Rufen Sie den Sentinel am Ende der Ansicht ab.
Geerbt von view_interface	Beschreibung
emptyC++20	Testen Sie, ob die Ansicht leer ist.
frontC++20	Rufen Sie das erste Element ab.
operator boolC++20	Testen Sie, ob die Ansicht nicht leer ist.

Anforderungen

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

Namespace:std::ranges

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

Konstruktoren

Erstellen einer Instanz einer split_view

1) split_view() requires default_initializable<V> && default_initializable<Pattern> = default;
2) constexpr 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 split_view(R&& rg, range_value_t<R> e);

Parameter

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

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

rg
Der bereich, der geteilt werden soll.

Informationen zu Vorlagenparametertypen finden Sie unter Vorlagenparameter.

Rückgabewert

Eine split_view Instanz, die eine oder mehrere Unterbereiche enthält.

Hinweise

Die beste Methode zum Erstellen eines Steuerelements split_view ist die Verwendung des views::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 split_view Standarddesign. Die zugrunde liegende Ansicht und pattern sind standardmäßig konstruiert. base() gibt eine Kopie von V().
2) Erstellen Sie eine split_view durch Teilen der Ansicht mithilfe einer Abfolge von Trennzeichen.
3) Erstellen Sie eine split_view durch Teilen der Ansicht mithilfe eines einzelnen Trennzeichens.

Beispiel: 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
    {
        for (auto& i : splitRange)
        {
            std::cout << i << " "; // 1 1 4 5 6
        }
    }
}

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

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.

constexpr auto end();

Parameter

Keine

Rückgabewert

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

Weitere Informationen

<ranges>
split_view Range Adaptor
lazy_split_view-Klasse
Anzeigen von Klassen