Namespaces
Variants

    std::ranges::views::chunk_by, std::ranges::chunk_by_view

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Range-Adaptoren
     
    std::ranges::chunk_by_view
     
    Definiert in Header <ranges> 
    template< ranges::forward_range V, std::indirect_binary_predicate<iterator_t<V>,
          ranges::iterator_t<V>> Pred >
    requires ranges::view<V> && std::is_object_v<Pred>
class chunk_by_view
    : public ranges::view_interface<chunk_by_view<V, Pred>>
    		(1) (seit C++23) 
    namespace views {
    inline constexpr /* unspecified */ chunk_by = /* unspecified */ ;
}
    		(2) (seit C++23)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R, class Pred >
    requires /* see below */
constexpr ranges::view auto chunk_by( R&& r, Pred&& pred );
    		(seit C++23) 
    template< class Pred >
constexpr /*range adaptor closure*/ chunk_by( Pred&& pred );
    		(seit C++23)
    1) chunk_by_view ist ein range adaptor, der eine view und ein invocable object pred (das binäre Prädikat) nimmt und eine view von subranges (Chunks) erzeugt, indem die zugrundeliegende view zwischen jedem Paar benachbarter Elemente, für die pred false zurückgibt, aufgeteilt wird. Das erste Element jedes solchen Paars gehört zum vorherigen Chunk, und das zweite Element gehört zum nächsten Chunk.
    2) Der Name views::chunk_by bezeichnet ein RangeAdaptorObject. Gegeben einen Teilausdruck e und f, ist der Ausdruck views::chunk_by(e, f) ausdrucksäquivalent zu chunk_by_view(e, f).

    chunk_by_view modelliert immer forward_range und modelliert bidirectional_range und/oder common_range, falls der adaptierte view-Typ die entsprechenden Konzepte modelliert. chunk_by_view modelliert nie borrowed_range oder sized_range.

    Datenmitglieder

    Member Definition
    V base_ die zugrundeliegende view
    ( Nur-Darstellungs-Memberobjekt* )
    movable-box <Pred> pred_ ein Objekt, das das Prädikat zum Aufteilen der Elemente von base_ umschließt
    ( Nur-Darstellungs-Memberobjekt* )
    non-propagating-cache <iterator> begin_ ein Objekt, das den Iterator zum ersten Element zwischenspeichert
    ( Nur-Darstellungs-Memberobjekt* )

    Memberfunktionen

    		konstruiert einen chunk_by_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)
    		gibt einen Iterator zum Anfang des nächsten Teilbereichs zurück
    ( Nur zur Darstellung verwendete Elementfunktion* )
    		gibt einen Iterator zum Anfang des vorherigen Teilbereichs zurück
    ( Nur zur Darstellung verwendete Elementfunktion* )
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete Sicht leer ist, bereitgestellt nur wenn sie sized_range oder forward_range
    erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Beginn des Bereichs zurück
    (öffentliche Member-Funktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Member-Funktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Sicht nicht leer ist, bereitgestellt nur wenn ranges::empty darauf anwendbar ist
    (öffentliche Member-Funktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Sicht zurück, bereitgestellt wenn sie forward_range
    erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Sicht zurück, bereitgestellt nur wenn sie bidirectional_range und common_range
    erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)

    Deduktionshilfen

    Geschachtelte Klassen

    		Der Iteratortyp
    ( Nur zur Darstellung dienende Member-Klassenvorlage* )

    Hinweise

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

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges_chunk_by 202202L (C++23) std::ranges::chunk_by_view

    Beispiel

    Diesen Code ausführen 
    #include <functional>
#include <iostream>
#include <ranges>
#include <string_view>
void print_chunks(auto view, std::string_view separator = ", ")
{
    for (auto const subrange : view)
    {
        std::cout << '[';
        for (std::string_view prefix; auto const& elem : subrange)
            std::cout << prefix << elem, prefix = separator;
        std::cout << "] ";
    }
    std::cout << '\n';
}
int main()
{
    std::initializer_list v1 = {1, 2, 3, 1, 2, 3, 3, 3, 1, 2, 3};
    auto fn1 = std::ranges::less{};
    auto view1 = v1 | std::views::chunk_by(fn1);
    print_chunks(view1);
    std::initializer_list v2 = {1, 2, 3, 4, 4, 0, 2, 3, 3, 3, 2, 1};
    auto fn2 = std::ranges::not_equal_to{};
    auto view2 = v2 | std::views::chunk_by(fn2);
    print_chunks(view2);
    std::string_view v3 = "__cpp_lib_ranges_chunk_by";
    auto fn3 = [](auto x, auto y) { return not(x == '_' or y == '_'); };
    auto view3 = v3 | std::views::chunk_by(fn3);
    print_chunks(view3, "");
    std::string_view v4 = "\u007a\u00df\u6c34\u{1f34c}"; // "zß水🍌"
    auto fn4 = [](auto, auto ß) { return 128 == ((128 + 64) & ß); };
    auto view4 = v4 | std::views::chunk_by(fn4);
    print_chunks(view4, "");
}

    Ausgabe: 

    [1, 2, 3] [1, 2, 3] [3] [3] [1, 2, 3] 
[1, 2, 3, 4] [4, 0, 2, 3] [3] [3, 2, 1] 
[_] [_] [cpp] [_] [lib] [_] [ranges] [_] [chunk] [_] [by]
[z] [ß] [水] [🍌]

    Referenzen

    • C++23-Standard (ISO/IEC 14882:2024):
    • 26.7.30 Chunk by view [range.chunk.by]

    Siehe auch

    (C++23)
    		eine Range von view s , die aus nicht überlappenden aufeinanderfolgenden N -großen Blöcken der Elemente einer anderen view bestehen
    (Klassentemplate) (Range-Adapter-Objekt)
    (C++23)
    		eine view , deren M tes Element eine view über die M ten bis (M + N - 1) ten Elemente einer anderen view ist
    (Klassentemplate) (Range-Adapter-Objekt)
    (C++23)
    		eine view , die aus Elementen einer anderen view besteht und jeweils um N Elemente voranschreitet
    (Klassentemplate) (Range-Adapter-Objekt)