Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::chunk_by_view
Definiert im 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 /* nicht spezifiziert */ chunk_by = /* nicht spezifiziert */ ;

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

requires /* siehe unten */

constexpr ranges:: view auto chunk_by ( R && r, Pred && pred ) ;
(seit C++23)
template < class Pred >
constexpr /*Range-Adapter-Closure*/ chunk_by ( Pred && pred ) ;
(seit C++23)
1) chunk_by_view ist ein Range-Adaptor, der eine view und ein aufrufbares Objekt pred (das binäre Prädikat) nimmt und eine view von Subranges (Chunks) erzeugt, indem die zugrundeliegende View zwischen jedem Paar benachbarter Elemente geteilt wird, für die pred den Wert false zurückgibt. Das erste Element jedes solchen Paares gehört zum vorherigen Chunk und das zweite Element gehört zum nächsten Chunk.
2) Der Name views :: chunk_by bezeichnet ein RangeAdaptorObject . Für einen gegebenen Subausdruck e und f ist der Ausdruck views :: chunk_by ( e, f ) ausdrucksäquivalent zu chunk_by_view ( e, f ) .

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

Inhaltsverzeichnis

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 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> )
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> )

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)