Namespaces
Variants

std::ranges:: views:: split, std::ranges:: split_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::split_view
Definiert im Header <ranges>
template < ranges:: forward_range V, ranges:: forward_range Pattern >

requires ranges:: view < V > &&
ranges:: view < Pattern > &&
std:: indirectly_comparable < ranges:: iterator_t < V > ,
ranges:: iterator_t < Pattern > ,
ranges:: equal_to >
class split_view

: public ranges:: view_interface < split_view < V, Pattern >>
(1) (seit C++20)
namespace views {

inline constexpr /* nicht spezifiziert */ split = /* nicht spezifiziert */ ;

}
(2) (seit C++20)
Aufrufsignatur
template < ranges:: viewable_range R, class Pattern >

requires /* siehe unten */

constexpr ranges:: view auto split ( R && r, Pattern && pattern ) ;
(seit C++20)
template < class Pattern >
constexpr /* Bereichsadapter-Abschluss */ split ( Pattern && pattern ) ;
(seit C++20)
1) split_view nimmt eine view und ein Trennzeichen und teilt die view in Subbereiche anhand des Trennzeichens auf.
2) RangeAdaptorObject . Der Ausdruck views :: split ( e, p ) ist ausdrucksäquivalent zu split_view ( e, p ) für beliebige geeignete Teilausdrücke e und p .

split_view modelliert die Konzepte forward_range und common_range , wenn die zugrundeliegende view V die jeweiligen Konzepte modelliert.

Der innere Bereich ( ranges:: range_reference_t < split_view > ) ist ein ranges:: subrange < ranges:: iterator_t < V >> , der common_range modelliert, sized_range modelliert, wenn ranges:: iterator_t < V > std:: sized_sentinel_for < ranges:: iterator_t < V >> modelliert, und contiguous_range , random_access_range , bidirectional_range sowie forward_range modelliert, wenn V die entsprechenden Konzepte modelliert.

Im Gegensatz zu lazy_split_view behält split_view die Kontinuität des Subbereichs bei, was es für String-Aufteilung geeignet macht.

Inhaltsverzeichnis

Datenmitglieder

Member Beschreibung
V base_ (private) die zugrundeliegende (angepasste) view
( exposition-only member object* )
Pattern pattern_ (private) das Musterobjekt, das als Trennzeichen zum Aufteilen der zugrundeliegenden view verwendet wird
( exposition-only member object* )
non-propagating-cache < ranges:: subrange
< ranges:: iterator_t < V >>> cached_begin_ (private) 		ein Objekt, das das Ergebnis des ersten Aufrufs von begin() zwischenspeichert
( exposition-only member object* )

Memberfunktionen

konstruiert einen split_view
(öffentliche Elementfunktion)
gibt eine Kopie der zugrunde liegenden (angepassten) Ansicht zurück
(öffentliche Elementfunktion)
gibt einen Iterator zum Anfang zurück
(öffentliche Elementfunktion)
gibt einen Iterator oder einen Sentinel zum Ende zurück
(öffentliche Elementfunktion)
sucht nach dem nächsten Vorkommen des Musters
( Nur zur Darstellung verwendete Elementfunktion* )
Geerbt von std::ranges::view_interface
gibt zurück, ob die abgeleitete Ansicht leer ist, bereitgestellt nur wenn sie sized_range oder forward_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
(C++23)
gibt einen konstanten Iterator zum Anfang des Bereichs zurück
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
(C++23)
gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt zurück, ob die abgeleitete Ansicht nicht leer ist, bereitgestellt nur wenn ranges::empty darauf anwendbar ist
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das erste Element in der abgeleiteten Ansicht zurück, bereitgestellt wenn sie forward_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )

Geschachtelte Klassen

der Iteratortyp
( Nur zur Darstellung dienende Memberklasse* )
der Sentineltyp
( Nur zur Darstellung dienende Memberklasse* )

Deduktionshilfen

Hinweise

Vor P2210R2 verwendete split_view einen lazy -Mechanismus für die Aufteilung und konnte daher die bidirektionalen, wahlfreien Zugriffs- oder zusammenhängenden Eigenschaften der zugrunde liegenden Ansicht nicht beibehalten oder den Iteratortyp des inneren Bereichs gleich dem der zugrunde liegenden Ansicht machen. Daher wurde es von P2210R2 neu gestaltet, und der lazy-Mechanismus wurde zu lazy_split_view verschoben.

Das Trennzeichen pattern sollte generell kein gewöhnlicher String-Literal sein, da es den Null-Terminator als notwendigen Teil des Trennzeichens betrachten wird; daher ist es ratsam, stattdessen einen std::string_view -Literal zu verwenden.

Beispiel

Diesen Code ausführen 
#include <iomanip>
#include <iostream>
#include <ranges>
#include <string_view>
int main()
{
    using std::operator""sv;
    constexpr auto words{"Hello^_^C++^_^20^_^!"sv};
    constexpr auto delim{"^_^"sv};
    for (const auto word : std::views::split(words, delim))
        // with string_view's C++23 range constructor:
        std::cout << std::quoted(std::string_view(word)) << ' ';
    std::cout << '\n';
}

Ausgabe: 

"Hello" "C++" "20" "!"
**Übersetzte Elemente:** - "Run this code" → "Diesen Code ausführen" - "Output:" → "Ausgabe:" **Nicht übersetzte Elemente:** - Alle HTML-Tags und Attribute - Code innerhalb der ` 
` und `` Tags (C++ Code)
- C++ spezifische Begriffe und Syntax
- Kommentare im Code (wie "// with string_view's C++23 range constructor:")
- Ausgabetext im Output-Bereich

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
P2210R2 C++20 die alte split_view war zu träge für eine einfache Verwendung sie wurde neu gestaltet

Siehe auch

(C++20)
eine view über die Teilbereiche, die durch Aufteilung einer anderen view mittels eines Trennzeichens erhalten werden
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view bestehend aus der Sequenz, die durch Abflachen einer view von range s erhalten wird
(Klassentemplate) (Range-Adapter-Objekt)