Namespaces
Variants

std::ranges:: views:: lazy_split, std::ranges:: lazy_split_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::lazy_split_view
Definiert im Header <ranges>
template < ranges:: input_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 > &&
( ranges:: forward_range < V > || /*tiny-range*/ < Pattern > )
class lazy_split_view

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

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

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

requires /* siehe unten */

constexpr ranges:: view auto lazy_split ( R && r, Pattern && pattern ) ;
(seit C++20)
template < class Pattern >
constexpr /* Bereichsadapter-Abschluss */ lazy_split ( Pattern && pattern ) ;
(seit C++20)
Hilfskonzepte
template < class R >

concept /*tiny-range*/ =
ranges:: sized_range < R > &&
requires { /* is-statically-constexpr-sized */ < R > ; } &&

( std:: remove_reference_t < R > :: size ( ) <= 1 ) ;
(3) ( nur zur Darstellung* )
1) lazy_split_view nimmt eine view und ein Trennzeichen und teilt die view in Subbereiche am Trennzeichen auf.

Zwei Hauptszenarien werden unterstützt:

2) Ein RangeAdaptorObject . Der Ausdruck views :: lazy_split ( e, f ) ist ausdrucksäquivalent zu lazy_split_view ( e, f ) .
3) Das exposition-only Konzept /*tiny-range*/ < Pattern > ist erfüllt, wenn Pattern sized_range erfüllt, Pattern :: size ( ) ein konstanter Ausdruck und als Template-Konstantenargument geeignet ist, und der Wert von Pattern :: size ( ) kleiner oder gleich 1 ist. Insbesondere erfüllen empty_view und single_view dieses Konzept.

lazy_split_view modelliert die Konzepte forward_range und input_range , wenn die zugrunde liegende view V die jeweiligen Konzepte modelliert, und modelliert common_range , wenn V sowohl forward_range als auch common_range modelliert.

Der innere Bereich ( ranges:: range_reference_t < lazy_split_view > ) modelliert die Konzepte forward_range und input_range , wenn die zugrundeliegende view V die jeweiligen Konzepte modelliert. Es modelliert nicht common_range und kann nicht mit Algorithmen verwendet werden, die einen bidirectional_range oder höher erwarten.

Im Gegensatz zu split_view bewahrt lazy_split_view nicht die Kontinuität des Subbereichs.

Inhaltsverzeichnis

Datenmitglieder

Member Beschreibung
V base_ (private) die zugrundeliegende view
( Nur zur Veranschaulichung verwendetes Member-Objekt* )
Pattern pattern_ (private) das Muster, das als Trennzeichen zum Aufteilen der zugrundeliegenden view verwendet wird
( Nur zur Veranschaulichung verwendetes Member-Objekt* )
non-propagating-cache < ranges:: iterator_t < V >> current_ (private)
(nur vorhanden, wenn V nicht forward_range erfüllt) 		ein Objekt, das das Ergebnis von Aufrufen an begin() zwischenspeichert
( Nur zur Veranschaulichung verwendetes Member-Objekt* )

Memberfunktionen

konstruiert einen lazy_split_view
(öffentliche Elementfunktion)
gibt eine Kopie der zugrundeliegenden (adaptierten) Ansicht zurück
(öffentliche Elementfunktion)
gibt einen Iterator zum Anfang zurück
(öffentliche Elementfunktion)
gibt einen Iterator oder Sentinel zum Ende zurück
(öffentliche 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 verwendete Member-Klassentemplate* )
der Iteratortyp des inneren Bereichs
( Nur zur Darstellung verwendete Member-Klassentemplate* )

Ableitungsleitfäden

Hinweise

Der Name lazy_split_view wurde durch den nach C++20 veröffentlichten Fehlerbericht P2210R2 eingeführt. Es besitzt den gleichen verzögerten Mechanismus wie der alte split_view vor der Änderung.

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>
auto print = [](auto const& view)
{
    // `view` ist vom Typ std::views::lazy_split_view::__outer_iterator::value_type
    for (std::cout << "{ "; const auto element : view)
        std::cout << element << ' ';
    std::cout << "} ";
};
int main()
{
    constexpr static auto source = {0, 1, 0, 2, 3, 0, 4, 5, 6, 0, 7, 8, 9};
    constexpr int delimiter{0};
    constexpr std::ranges::lazy_split_view outer_view{source, delimiter};
    std::cout << "splits[" << std::ranges::distance(outer_view) << "]:  ";
    for (auto const& inner_view: outer_view)
        print(inner_view);
    constexpr std::string_view hello{"Hello C++ 20 !"};
    std::cout << "\n" "substrings: ";
    std::ranges::for_each(hello | std::views::lazy_split(' '), print);
    constexpr std::string_view text{"Hello-+-C++-+-20-+-!"};
    constexpr std::string_view delim{"-+-"};
    std::cout << "\n" "substrings: ";
    std::ranges::for_each(text | std::views::lazy_split(delim), print);
}

Ausgabe: 

splits[5]:  { } { 1 } { 2 3 } { 4 5 6 } { 7 8 9 }
substrings: { H e l l o } { C + + } { 2 0 } { ! }
substrings: { H e l l o } { C + + } { 2 0 } { ! }

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 verlagert ihre Funktionalität zu lazy_split_view

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 Glätten einer view von range s erhalten wird
(Klassentemplate) (Range-Adapter-Objekt)