Namespaces
Variants

std::ranges:: views:: drop_while, std::ranges:: drop_while_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::drop_while_view
Definiert im Header <ranges>
template < ranges:: view V, class Pred >

requires ranges:: input_range < V > &&
std:: is_object_v < Pred > &&
std:: indirect_unary_predicate < const Pred, ranges:: iterator_t < V >>
class drop_while_view

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

inline constexpr /* unspecified */ drop_while = /* unspecified */ ;

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

requires /* siehe unten */

constexpr ranges:: view auto drop_while ( R && r, Pred && pred ) ;
(seit C++20)
template < class Pred >
constexpr /*range adaptor closure*/ drop_while ( Pred && pred ) ;
(seit C++20)
1) Ein Bereichsadapter, der eine view von Elementen aus einer zugrundeliegenden Sequenz darstellt, beginnend beim ersten Element, für das das Prädikat false zurückgibt.
2) RangeAdaptorObject . Der Ausdruck views :: drop_while ( e, f ) ist ausdrucksäquivalent zu drop_while_view ( e, f ) für beliebige geeignete Teilausdrücke e und f .

drop_while_view modelliert die Konzepte contiguous_range , random_access_range , bidirectional_range , forward_range , input_range und common_range , wenn die zugrundeliegende View V die jeweiligen Konzepte modelliert. Es modelliert außerdem sized_range , wenn ranges:: forward_range < V > und std:: sized_sentinel_for < ranges:: sentinel_t < V > , ranges:: iterator_t < V >> modelliert werden.

Inhaltsverzeichnis

Datenmitglieder

Member Beschreibung
V base_ (private) die zugrundeliegende Ansicht
( Nur zur Darstellung verwendetes Member-Objekt* )
copyable-box <Pred> (until C++23) movable-box <Pred> (since C++23) pred_ (private) das zugrundeliegende Funktionsobjekt
( Nur zur Darstellung verwendetes Member-Objekt* )
non-propagating-cache < ranges:: iterator_t < V >> cache_ (private)
(nur vorhanden, wenn V forward_range erfüllt) 		ein Objekt, das das Ergebnis von begin() zwischenspeichert
( Nur zur Darstellung verwendetes Member-Objekt* )

Memberfunktionen

konstruiert einen drop_while_view
(öffentliche Elementfunktion)
gibt eine Kopie der zugrundeliegenden (adaptierten) Ansicht zurück
(öffentliche Elementfunktion)
gibt eine Referenz auf das gespeicherte Prädikat 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> )
ruft die Adresse der Daten der abgeleiteten Ansicht ab, bereitgestellt nur wenn ihr Iteratortyp contiguous_iterator erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt die Anzahl der Elemente in der abgeleiteten Ansicht zurück. Bereitgestellt wenn sie forward_range erfüllt und ihr Sentinel- und Iteratortyp sized_sentinel_for erfüllen.
(ö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> )
gibt das letzte Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie bidirectional_range und common_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das n te Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie random_access_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )

Ableitungsleitfäden

Hilfsvorlagen

template < class T, class Pred >

constexpr bool enable_borrowed_range < std :: ranges :: drop_while_view < T, Pred >> =

ranges:: enable_borrowed_range < T > ;
(seit C++20)

Diese Spezialisierung von std :: ranges:: enable_borrowed_range bewirkt, dass drop_while_view borrowed_range erfüllt, wenn die zugrundeliegende View diese Bedingung erfüllt.

Hinweise

Um die amortisierte konstante Zeitkomplexität zu gewährleisten, die vom range -Konzept gefordert wird, wird das Ergebnis von begin innerhalb des drop_while_view -Objekts zwischengespeichert. Wenn der zugrundeliegende Bereich nach dem ersten Aufruf von begin() modifiziert wird, können nachfolgende Verwendungen des drop_while_view -Objekts unintuitives Verhalten aufweisen.

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <ranges>
#include <string>
#include <string_view>
using std::operator""sv;
[[nodiscard]]
constexpr bool is_space(char p) noexcept
{
    auto ne = [p](auto q) { return p != q; };
    return !!(" \t\n\v\r\f" | std::views::drop_while(ne));
};
[[nodiscard("trims the output")]]
constexpr std::string_view trim_left(std::string_view const in) noexcept
{
    auto view = in | std::views::drop_while(is_space);
    return {view.begin(), view.end()};
}
[[nodiscard("trims the output")]]
constexpr std::string trim(std::string_view const in)
{
    auto view = in
              | std::views::drop_while(is_space)
              | std::views::reverse
              | std::views::drop_while(is_space)
              | std::views::reverse
              ;
    return {view.begin(), view.end()};
}
int main()
{
    static_assert(trim_left(" \n C++23") == "C++23"sv);
    constexpr auto src{" \f\n\t\r\vHello, C++20!\f\n\t\r\v "sv};
    static_assert(trim(src) == "Hello, C++20!");
    static constexpr auto v = {0, 1, 2, 3, 4, 5};
    for (int n : v | std::views::drop_while([](int i) { return i < 3; }))
        std::cout << n << ' ';
    std::cout << '\n';
}

Ausgabe: 

3 4 5

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
LWG 3494 C++20 drop_while_view war nie ein borrowed_range es ist ein borrowed_range wenn seine zugrunde liegende Ansicht es ist

Siehe auch

(C++20)
eine view , bestehend aus Elementen einer anderen view , die die ersten N Elemente überspringt
(Klassentemplate) (Range-Adapter-Objekt)