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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bereichsbibliothek

Bereichszugriff begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata reserve_hint (C++26)   empty

Range-Konvertierungen std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Behandlung von hängenden Iteratoren dangling borrowed_iterator_t borrowed_subrange_t

Range-Primitive
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Range-Konzepte
range borrowed_range    common_range	sized_range viewable_range    view	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	approximately_sized_range (C++26) constant_range (C++23)

Ansichten
view_interface	subrange

Range-Fabriken
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Range-Adaptoren
views::all_tviews::all as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while common_viewviews::common views::counted to_input_viewviews::to_input (C++26)(C++26)	ref_view drop_viewviews::drop drop_while_viewviews::drop_while lazy_split_viewviews::lazy_split split_viewviews::split join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   concat_viewviews::concat (C++26)(C++26) cache_latest_viewviews::cache_latest (C++26)(C++26)	owning_view reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Range generators std::generator (C++23)

Range-Adaptor-Closure-Objekte range_adaptor_closure (C++23)

Range-Adaptor-Objekte

Hilfselemente
copyable-box movable-box (bis C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::chunk_by_view

Memberfunktionen

chunk_by_view::chunk_by_view

chunk_by_view::base

chunk_by_view::pred

chunk_by_view::begin

chunk_by_view::end

chunk_by_view::find_next

chunk_by_view::find_prev

Deduction Guides

Iterator

chunk_by_view::iterator::iterator

chunk_by_view::iterator::operator*

chunk_by_view::iterator::operator++ chunk_by_view::iterator::operator++(int) chunk_by_view::iterator::operator-- chunk_by_view::iterator::operator--(int)

operator==(chunk_by_view::iterator)

 

Definiert in der Header-Datei <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)
Aufruf-Signatur
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 adaptor closure*/ chunk_by( Pred&& pred );		(seit C++23)

1) chunk_by_view ist ein Range-Adapter, der eine view und ein aufrufbaren Objekt pred (die binäre Prädikatfunktion) entgegennimmt und eine view von Teilbereichen (Chunks) erzeugt, indem die zugrunde liegende View zwischen jedem Paar benachbarter Elemente aufgeteilt wird, für die pred 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 Unterausdruck 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, wenn die angepasste view-Typ die entsprechenden Konzepte modelliert. chunk_by_view modelliert nie borrowed_range oder sized_range.

Datenelemente

Mitglied	Definition
V base_	die zugrunde liegende view ((exposition-only member object*)
movable-box<Pred> pred_	ein Objekt, das die Prädikatfunktion zum Aufteilen der Elemente von base_ umschließt ((exposition-only member object*)
non-propagating-cache<iterator> begin_	ein Objekt, das den Iterator zum ersten Element zwischenspeichert ((exposition-only member object*)

Memberfunktionen

(Konstruktor)	konstruiert eine chunk_by_view (öffentliche Member-Funktion)
base	gibt eine Kopie der zugrunde liegenden (angepassten) View zurück (public member function)
pred	gibt eine Referenz auf die gespeicherte Prädikatfunktion zurück (public member function)
begin	gibt einen Iterator zum Anfang zurück (öffentliche Member-Funktion)
end	gibt einen Iterator oder Sentinel zum Ende zurück (öffentliche Member-Funktion)
find_next	gibt einen Iterator zum Beginn des nächsten Teilbereichs zurück (exposition-only Member-Funktion*)
find_prev	gibt einen Iterator zum Beginn des vorherigen Teilbereichs zurück (exposition-only Member-Funktion*)
Geerbt von std::ranges::view_interface
empty	gibt zurück, ob die abgeleitete Ansicht leer ist, bereitgestellt nur, wenn sie sized_range oder forward_range erfüllt (public member function of std::ranges::view_interface<D>)
cbegin (C++23)	gibt einen konstanten Iterator zum Anfang des Bereichs zurück (public member function of std::ranges::view_interface<D>)
cend (C++23)	gibt ein Sentinel für den konstanten Iterator des Bereichs zurück (public member function of std::ranges::view_interface<D>)
operator bool	gibt zurück, ob die abgeleitete Ansicht nicht leer ist, bereitgestellt nur, wenn ranges::empty darauf anwendbar ist (public member function of std::ranges::view_interface<D>)
front	gibt das erste Element in der abgeleiteten View zurück, bereitgestellt, wenn sie forward_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
back	gibt das letzte Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie bidirectional_range und common_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)

Verschachtelte Klassen

iterator

der Iterator-Typ ((nur zur Veranschaulichung Exposition-only Member-Klassenschablone)*)

Anmerkungen

Um die vom range-Konzept geforderte amortisierte konstante Zeitkomplexität zu bieten, wird das Ergebnis von begin() innerhalb des chunk_by_view-Objekts zwischengespeichert. Wenn der zugrunde liegende Bereich nach dem ersten Aufruf von begin() geändert wird, können nachfolgende Verwendungen des chunk_by_view-Objekts zu unerwartetem Verhalten führen.

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

Beispiel

Führen Sie diesen Code aus

#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

ranges::chunk_viewviews::chunk (C++23)	eine Reihe von views, die N-elementige, nicht überlappende, aufeinanderfolgende Blöcke von Elementen einer anderen view sind (Klassenschablone) (Range-Adaptor-Objekt)
ranges::slide_viewviews::slide (C++23)	eine view, deren M-tes Element eine view über die M-ten bis (M + N - 1)-ten Elemente einer anderen view ist (Klassenschablone) (Range-Adaptor-Objekt)
ranges::stride_viewviews::stride (C++23)	eine view, die aus Elementen einer anderen view besteht und dabei jeweils N Elemente überspringt (Klassenschablone) (Range-Adaptor-Objekt)