Namespaces
Variants

std::ranges:: views:: chunk, std::ranges:: chunk_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::chunk_view
Member functions
(C++26)
Classes for input_range s
Deduction guides
outer-iterator
outer-iterator ::value_type
inner-iterator
Definiert im Header <ranges>
template < ranges:: view V >

requires ranges:: input_range < V >
class chunk_view

: public ranges:: view_interface < chunk_view < V >>
(1) (seit C++23)
template < ranges:: view V >

requires ranges:: forward_range < V >
class chunk_view < V >

: public ranges:: view_interface < chunk_view < V >>
(2) (seit C++23)
namespace views {

inline constexpr /* unspecified */ chunk = /* unspecified */ ;

}
(3) (seit C++23)
Aufrufsignatur
template < ranges:: viewable_range R >
constexpr ranges:: view auto chunk ( R && r, ranges:: range_difference_t < R > n ) ;
(seit C++23)
template < class DifferenceType >
constexpr /*range adaptor closure*/ chunk ( DifferenceType && n ) ;
(seit C++23)
Hilfsvorlagen
template < class I >
constexpr I /*div-ceil*/ ( I num, I denom ) ;
(4) ( nur zur Darstellung* )

chunk_view nimmt eine view und eine Zahl n und erzeugt einen Bereich von Views (die chunks  ) der ursprünglichen View, sodass jeder chunk  , außer möglicherweise dem letzten, die Größe n hat. Diese chunks sind nicht überlappende, aufeinanderfolgende Teilbereiche der Elemente der ursprünglichen View in Reihenfolge.

Sei s die Größe der ursprünglichen Ansicht. Wenn s kein Vielfaches von n ist, beträgt die Größe der letzten erzeugten Ansicht exakt s % n (der Rest). Andernfalls ist die Größe jedes Chunks , einschließlich des letzten, n .

Die Größe der erzeugten Ansicht ist /*div-ceil*/ ( s ) .

Wenn n nicht größer als ​ 0 ​ ist, ist das Verhalten undefiniert.

1) Eine Implementierung, die die zugrundeliegende Ansicht V unterstützt, die nur input_range modelliert.
2) Eine partielle Spezialisierung, die die zugrundeliegende Sicht V unterstützt, die forward_range oder stärker modelliert. Modelliert common_range , wenn die zugrundeliegende Sicht V ein forward_range , common_range und entweder ein sized_range oder kein bidirectional_range ist.
3) Der Name views :: chunk bezeichnet ein RangeAdaptorObject . Für gegebene Subausdrücke e und n ist der Ausdruck views :: chunk ( e, n ) ausdrucksäquivalent zu chunk_view ( e, n ) .
4) Berechnet den kleinsten ganzzahligen Wert, der nicht kleiner ist als der Quotient aus der Division von num durch denom . Entspricht: 
I r = num / denom;
if (num % denom)
    ++r;
return r;

Inhaltsverzeichnis

Datenmitglieder

Member Beschreibung
V base_ die zugrundeliegende Ansicht
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
ranges:: range_difference_t < V > n_ die "Chunk"-Größe
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
Wenn V exakt input_range ( 1 ) modelliert
ranges:: range_difference_t < V > remainder_
(bedingt vorhanden) 		die Anzahl der im aktuellen "Chunk" verbleibenden Elemente
( Nur-Darstellungs-Memberobjekt* )
non-propagating-cache < ranges:: iterator_t < V >> current_
(bedingt vorhanden) 		ein Objekt, das den aktuellen zugrundeliegenden Iterator zwischenspeichert
( Nur-Darstellungs-Memberobjekt* )

Memberfunktionen

konstruiert einen chunk_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 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> )
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> )

Deduktionshilfen

Geschachtelte Klassen

(C++23)
der Ausgabe-("chunk-weise") Iteratortyp, wenn V input_range modelliert ( 1 )
( Nur zur Darstellung verwendete Memberklasse* )
(C++23)
der innere ("element-weise") Iteratortyp, wenn V input_range modelliert ( 1 )
( Nur zur Darstellung verwendete Memberklasse* )
(C++23)
der Iteratortyp, wenn V forward_range modelliert ( 2 )
( Nur zur Darstellung verwendete Memberklassenvorlage* )

Hilfsvorlagen

template < class V >

constexpr bool ranges:: enable_borrowed_range < chunk_view < V >> =

ranges:: forward_range < V > && ranges:: enable_borrowed_range < V > ;
(seit C++23)

Diese Spezialisierung von ranges::enable_borrowed_range bewirkt, dass chunk_view die Anforderungen von borrowed_range erfüllt, wenn die zugrundeliegende View V sowohl forward_range als auch borrowed_range erfüllt.

Hinweise

Wenn V ein input_range ( 1 ) modelliert, dann hat der Iterator von chunk_view einen speziellen Typ: outer_iterator::value_type , der selbst eine Eingabeansicht ist.

Wenn V ein forward_range oder stärker modelliert ( 2 ) , delegiert chunk_view an views::take für seinen value_type .

Wenn V bidirectional_range oder stärkere Ranges modelliert ( 2 ) , erfordert die Notwendigkeit, die Größe des letzten Chunks korrekt zu berechnen (vom Ende- Iterator ), dass der zugrundeliegende Range-Typ V ein sized_range ist.

Feature-Test Makro Wert Standard Funktion
__cpp_lib_ranges_chunk 202202L (C++23) std::ranges::chunk_view

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <ranges>
auto print_subrange = [](std::ranges::viewable_range auto&& r)
{
    std::cout << '[';
    for (int pos{}; auto elem : r)
        std::cout << (pos++ ? " " : "") << elem;
    std::cout << "] ";
};
int main()
{
    const auto v = {1, 2, 3, 4, 5, 6};
    for (const unsigned width : std::views::iota(1U, 2U + v.size()))
    {
        auto const chunks = v | std::views::chunk(width);
        std::cout << "chunk(" << width << "): ";
        std::ranges::for_each(chunks, print_subrange);
        std::cout << '\n';
    }
}

Ausgabe: 

chunk(1): [1] [2] [3] [4] [5] [6]
chunk(2): [1 2] [3 4] [5 6]
chunk(3): [1 2 3] [4 5 6]
chunk(4): [1 2 3 4] [5 6]
chunk(5): [1 2 3 4 5] [6]
chunk(6): [1 2 3 4 5 6]
chunk(7): [1 2 3 4 5 6]

Referenzen

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

Siehe auch

(C++23)
teilt die view in Subbereiche zwischen jedem Paar benachbarter Elemente auf, für die das gegebene Prädikat false zurückgibt
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
eine view bestehend aus Tupeln von Referenzen auf benachbarte Elemente der adaptierten View
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
eine view deren M tes Element eine view über das M te bis (M + N - 1) te Element einer anderen view ist
(Klassentemplate) (Range-Adapter-Objekt)