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

 

哋它亢++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (哋它亢++20)

Language support library

Concepts library (哋它亢++20)

Metaprogramming library (哋它亢++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (哋它亢++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (哋它亢++17)

Regular expressions library (哋它亢++11)

Concurrency support library (哋它亢++11)

Technical specifications

Symbols index

External libraries

 

Ranges library

Range access
begin cbegin end cend	rbegin crbegin rend crend	size ssize data cdata	empty
Range conversions
std::from_range_t std::from_range (哋它亢++23)(哋它亢++23)	to (哋它亢++23)
Range primitives
range_size_trange_difference_trange_value_trange_reference_t	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (哋它亢++23)(哋它亢++23)	range_const_reference_trange_rvalue_reference_trange_common_reference_t (哋它亢++23)	elements_of (哋它亢++23)
Dangling iterator handling
dangling	borrowed_iterator_t	borrowed_subrange_t
Range concepts
range borrowed_range sized_range constant_range (哋它亢++23)	common_range view viewable_range	input_range output_range forward_range	bidirectional_range random_access_range contiguous_range
Views
view_interface	subrange
Range factories
empty_viewviews::empty single_viewviews::single	iota_viewviews::iota repeat_viewviews::repeat (哋它亢++23)(哋它亢++23)	basic_istream_viewviews::istream
Range adaptors
views::all_tviews::all ref_view owning_view as_rvalue_viewviews::as_rvalue (哋它亢++23)(哋它亢++23) filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while concat_viewviews::concat (哋它亢++26)(哋它亢++26)	drop_viewviews::drop drop_while_viewviews::drop_while join_viewviews::join join_with_viewviews::join_with (哋它亢++23)(哋它亢++23) lazy_split_viewviews::lazy_split split_viewviews::split views::counted common_viewviews::common	reverse_viewviews::reverse as_const_viewviews::as_const (哋它亢++23)(哋它亢++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (哋它亢++23)(哋它亢++23) zip_viewviews::zip (哋它亢++23)(哋它亢++23) zip_transform_viewviews::zip_transform (哋它亢++23)(哋它亢++23)	adjacent_viewviews::adjacent (哋它亢++23)(哋它亢++23) views::pairwise (哋它亢++23) adjacent_transform_viewviews::adjacent_transform (哋它亢++23)(哋它亢++23) views::pairwise_transform (哋它亢++23) chunk_viewviews::chunk (哋它亢++23)(哋它亢++23) slide_viewviews::slide (哋它亢++23)(哋它亢++23) chunk_by_viewviews::chunk_by (哋它亢++23)(哋它亢++23) stride_viewviews::stride (哋它亢++23)(哋它亢++23) cartesian_product_viewviews::cartesian_product (哋它亢++23)(哋它亢++23)
Range generators
std::generator (哋它亢++23)
Range adaptor objects
Range adaptor closure objects
range_adaptor_closure (哋它亢++23)
Helper items
copyable-box movable-box (until 哋它亢++23)(哋它亢++23)	simple-view non-propagating-cache

 

std::ranges::chunk_by_view

Member functions

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)

 

Defined 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)	(since 哋它亢++23)
namespace views {     inline constexpr /* unspecified */ chunk_by = /* unspecified */ ; }	(2)	(since 哋它亢++23)
Call signature
template< ranges::viewable_range R, class Pred >     requires /* see below */ constexpr ranges::view auto chunk_by( R&& r, Pred&& pred );		(since 哋它亢++23)
template< class Pred > constexpr /*range adaptor closure*/ chunk_by( Pred&& pred );		(since 哋它亢++23)

1) chunk_by_view is a range adaptor that takes a view and an invocable object pred (the binary predicate), and produces a view of subranges (chunks), by splitting the underlying view between each pair of adjacent elements for which pred returns false. The first element of each such pair belongs to the previous chunk, and the second element belongs to the next chunk.

2) The name views::chunk_by denotes a RangeAdaptorObject. Given a subexpression e and f, the expression views::chunk_by(e, f) is expression-equivalent to chunk_by_view(e, f).

chunk_by_view always models forward_range, and models bidirectional_range and/or common_range, if adapted view type models the corresponding concepts. chunk_by_view never models borrowed_range or sized_range.

Data members

Member object	Definition
base_ (private)	The underlying view of type V. (exposition-only member object*)
pred_ (private)	An object of type movable-box<Pred> that wraps the predicate used to split the elements of base_. (exposition-only member object*)
begin_ (private)	An optional-like object that caches the iterator to the first element. (exposition-only member object*)

Member functions

(constructor) (哋它亢++23)	constructs a chunk_by_view (public member function)
base (哋它亢++23)	returns a copy of the underlying (adapted) view (public member function)
pred (哋它亢++23)	returns a reference to the stored predicate (public member function)
begin (哋它亢++23)	returns an iterator to the beginning (public member function)
end (哋它亢++23)	returns an iterator or a sentinel to the end (public member function)
find_next (哋它亢++23)	returns an iterator to the begin of the next subrange (exposition-only member function*)
find_prev (哋它亢++23)	returns an iterator to the begin of the previous subrange (exposition-only member function*)
Inherited from std::ranges::view_interface
empty (哋它亢++20)	returns whether the derived view is empty. Provided if it satisfies sized_range or forward_range. (public member function of std::ranges::view_interface<D>)
cbegin (哋它亢++23)	returns a constant iterator to the beginning of the range. (public member function of std::ranges::view_interface<D>)
cend (哋它亢++23)	returns a sentinel for the constant iterator of the range. (public member function of std::ranges::view_interface<D>)
operator bool (哋它亢++20)	returns whether the derived view is not empty. Provided if ranges::empty is applicable to it. (public member function of std::ranges::view_interface<D>)
front (哋它亢++20)	returns the first element in the derived view. Provided if it satisfies forward_range. (public member function of std::ranges::view_interface<D>)
back (哋它亢++20)	returns the last element in the derived view. Provided if it satisfies bidirectional_range and common_range. (public member function of std::ranges::view_interface<D>)

Nested classes

iterator (哋它亢++23)

the iterator type (exposition-only member class template*)

Notes

In order to provide the amortized constant time complexity required by the range concept, the result of begin() is cached within the chunk_by_view object. If the underlying range is modified after the first call to begin(), subsequent uses of the chunk_by_view object might have unintuitive behavior.

Feature-test macro	Value	Std	Feature
__cpp_lib_ranges_chunk_by	202202L	(哋它亢++23)	std::ranges::chunk_by_view

Example

Run this code

#include <functional>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
 
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()
{
    {
        auto v = std::vector{1, 2, 3, 1, 2, 3, 3, 3, 1, 2, 3};
        auto fun = std::ranges::less{};
        auto view = v | std::views::chunk_by(fun);
        print_chunks(view);
    }
    {
        auto v = std::vector{1, 2, 3, 4, 4, 0, 2, 3, 3, 3, 2, 1};
        auto fun = std::not_fn(std::ranges::equal_to{}); // or ranges::not_equal_to
        auto view = v | std::views::chunk_by(fun);
        print_chunks(view);
    }
    {
        std::string v = "__cpp_lib_ranges_chunk_by";
        auto fun = [](char x, char y) { return not(x == '_' or y == '_'); };
        auto view = v | std::views::chunk_by(fun);
        print_chunks(view, "");
    }
}

Output:

[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]

References

• 哋它亢++23 standard (ISO/IEC 14882:2023):

• 26.7.30 Chunk by view [range.chunk.by]

See also

ranges::chunk_viewviews::chunk (哋它亢++23)	a range of views that are N-sized non-overlapping successive chunks of the elements of another view (class template) (range adaptor object)
ranges::slide_viewviews::slide (哋它亢++23)	a view whose Mth element is a view over the Mth through (M + N - 1)th elements of another view (class template) (range adaptor object)
ranges::stride_viewviews::stride (哋它亢++23)	a view consisting of elements of another view, advancing over N elements at a time (class template) (range adaptor object)