Namespaces
Variants

    std::ranges::views::drop, std::ranges::drop_view

    Von de.cppreference.net
     
    C++
     
    Bereichsbibliothek
    Bereichsadaptoren
     
    std::ranges::drop_view
     
    Definiert in Header <ranges> 
    template< ranges::view V >
class drop_view
    : public ranges::view_interface<drop_view<V>>
    		(1) (seit C++20) 
    namespace views {
    inline constexpr /* unspecified */ drop = /* unspecified */;
}
    		(2) (seit C++20)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto
    drop( R&& r, ranges::range_difference_t<R> count );
    		(seit C++20) 
    template< class DifferenceType >
constexpr /* range adaptor closure */ drop( DifferenceType&& count );
    		(seit C++20)
    1) Ein Bereichsadaptor, der aus Elementen der zugrunde liegenden Sequenz besteht, wobei die ersten N Elemente weggelassen werden.
    2) RangeAdaptorObject. Gegeben T ist std::remove_cvref_t<decltype((e))> und D ist ranges::range_difference_t<decltype((e))>), ist der Ausdruck views::drop(e, f) zu ausdrucksäquivalent:
    • ((void)f, decay-copy(e)), wenn T ein ranges::empty_view ist, außer dass die Auswertungen von e und f unbestimmt sequenziert sind;
    • andernfalls T(ranges::begin(e) + inc, ranges::end(e),
      /*to-unsigned-like*/(ranges::distance(e) - inc))      , wenn T eine Spezialisierung von ranges::subrange ist, die sowohl random_access_range als auch sized_range modelliert, und T die Größe speichern muss (siehe ranges::subrange::subrange() für Details), wobei inc std::min<D>(ranges::distance(e), f) ist;
    • andernfalls U(ranges::begin(e) + inc, ranges::end(e)), wenn T eine Spezialisierung von std::span, std::basic_string_view, ranges::iota_view oder ranges::subrange ist, die sowohl random_access_range als auch sized_range modelliert, wobei U
    • std::span<typename T::element_type> ist, wenn T eine Spezialisierung von std::span ist;
    • T andernfalls;
    • views::repeat(*e.value_, ranges::distance(e) - inc), wenn T sized_range modelliert; in diesem Fall wird e nur einmal ausgewertet;
    • ((void)e, auto(f)) andernfalls, außer dass die Auswertungen von e und f unbestimmt sequenziert sind;
    		 (seit C++23)
    • andernfalls drop_view(e, f).
    In allen Fällen muss decltype((f)) std::convertible_to<D> modellieren.

    drop_view modelliert die Konzepte contiguous_range, random_access_range, bidirectional_range, forward_range, input_range, common_range und sized_range, wenn die zugrunde liegende Ansicht V die entsprechenden Konzepte modelliert.

    Datenelemente

    Mitglied Beschreibung
    V base_ (privat) die zugrunde liegende Ansicht
    (nur zur Darstellung dienendes Mitgliedsobjekt*)
    ranges::range_difference_t<V> count_ (privat) die Anzahl der zu überspringenden Elemente
    (nur zur Darstellung dienendes Mitgliedsobjekt*)
    nicht propagierender Cache<ranges::iterator_t<V>> cache_ (privat)
    (nur vorhanden, wenn V forward_range
    aber nicht random_access_range und sized_range erfüllt)         		ein Objekt, das das Ergebnis von Aufrufen an begin()
    (nur zur Darstellung dienendes Mitgliedsobjekt*)

    Memberfunktionen

    		konstruiert einen drop_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)
    		gibt die Anzahl der Elemente zurück, bereitgestellt nur wenn der zugrundeliegende (adaptierte) Bereich sized_range erfüllt
    (öffentliche Elementfunktion)
    (C++26)
    		gibt die ungefähre Größe des resultierenden approximately_sized_range zurück
    (öffentliche Elementfunktion)
    Geerbt von 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>)
    		erhält die Adresse der Daten der abgeleiteten Ansicht, bereitgestellt nur wenn ihr Iteratortyp contiguous_iterator
    erfüllt (ö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 nth 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 >

    constexpr bool enable_borrowed_range < std :: ranges :: drop_view < T >> =

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

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

    Beispiel

    Diesen Code ausführen 
    #include <initializer_list>
#include <iostream>
#include <ranges>
int main()
{
    const auto nums = {1, 2, 3, 4, 5, 6, 7};
    std::cout << "drop " << 2 << ": ";
    for (int i : std::ranges::drop_view{nums, 2})
        std::cout << i << ' ';
    std::cout << '\n';
    std::cout << "drop " << 3 << ": ";
    for (int i : nums | std::views::drop(3))
        std::cout << i << ' ';
    std::cout << '\n';
    std::cout << "drop " << 4 << ": ";
    for (int i : std::views::iota(1, 8) | std::views::drop(4))
        std::cout << i << ' ';
    std::cout << '\n';
    // Hinweis: Das Überspringen von mehr Elementen als vorhanden ist unproblematisch:
    for (int dp : {5, 6, 7, 890, 100500})
    {
        std::cout << "drop " << dp << ": ";
        for (int i : std::views::iota(1, 8) | std::views::drop(dp))
            std::cout << i << ' ';
        std::cout << '\n';
    }
}

    Ausgabe: 

    drop 2: 3 4 5 6 7
drop 3: 4 5 6 7
drop 4: 5 6 7
drop 5: 6 7
drop 6: 7
drop 7:
drop 890: 
drop 100500:

    Fehlerberichte

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

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 3407 C++20 views::drop konnte manchmal keinen
    sized random access range konstruieren     		die Konstruktion wurde angepasst,
    sodass sie immer gültig ist
    LWG 3494 C++20 drop_view war nie ein borrowed_range es ist ein borrowed_range wenn der zugrundeliegende View es ist

    Siehe auch

    (C++20)
    		eine view , bestehend aus den Elementen einer anderen view , die das anfängliche Elemente-Subsequenz überspringt, bis zum ersten Element, bei dem das Prädikat false zurückgibt
    (Klassen-Template) (Range-Adapter-Objekt)