NAME¶

std::ranges::views::lazy_split,std::ranges::lazy_split_view - std::ranges::views::lazy_split,std::ranges::lazy_split_view

Synopsis¶

Defined in header <ranges>
template< ranges::input_range V, ranges::forward_range Pattern >

requires ranges::view<V> &&
ranges::view<Pattern> &&
std::indirectly_comparable<ranges::iterator_t<V>,
ranges::iterator_t<Pattern>, (1) (since C++20)
ranges::equal_to> &&
(ranges::forward_range<V> || /*tiny-range*/<Pattern>)
class lazy_split_view

: public ranges::view_interface<lazy_split_view<V, Pattern>>
namespace views {

inline constexpr /* unspecified */ lazy_split = /* (2) (since C++20)
unspecified */;

}
Call signature
template< ranges::viewable_range R, class Pattern >

requires /* see below */ (since C++20)

constexpr ranges::view auto lazy_split( R&& r, Pattern&& pattern
);
template< class Pattern >
constexpr /* range adaptor closure */ lazy_split( Pattern&& (since C++20)
pattern );
Helper concepts
template< class R >

concept /*tiny-range*/ = (exposition
ranges::sized_range<R> && (3) only*)
requires { /* is-statically-constexpr-sized */<R>; } &&

(std::remove_reference_t<R>::size() <= 1);

1) lazy_split_view takes a view and a delimiter, and splits the view into subranges
on the delimiter.

Two major scenarios are supported:

* The view is an input_range, the delimiter is a single element (wrapped in a
single_view).
* The view is a forward_range, the delimiter is a view of elements.
2) A RangeAdaptorObject. The expression views::lazy_split(e, f) is
expression-equivalent to lazy_split_view(e, f).
3) The exposition-only concept /*tiny-range*/<Pattern> is satisfied if Pattern
satisfies sized_range, Pattern::size() is a constant expression and suitable as a
template non-type argument, and the value of Pattern::size() is less than or equal
to 1. Notably, empty_view and single_view satisfy this concept.

lazy_split_view models the concepts forward_range and input_range when the
underlying view V models respective concepts, and models common_range when V models
both forward_range and common_range.

The inner range (ranges::range_reference_t<lazy_split_view>) models the concepts
forward_range and input_range when the underlying view V models respective concepts.
It does not model common_range, and cannot be used with algorithms that expect a
bidirectional_range or higher.

Member functions¶

constructor constructs a lazy_split_view
(C++20) (public member function)
base returns a copy of the underlying (adapted) view
(C++20) (public member function)
begin returns an iterator to the beginning
(C++20) (public member function)
end returns an iterator or a sentinel to the end
(C++20) (public member function)
Inherited from std::ranges::view_interface
empty returns whether the derived view is empty. Provided if it satisfies
(C++20) sized_range or forward_range.
(public member function of std::ranges::view_interface<D>)
cbegin returns a constant iterator to the beginning of the range.
(C++23) (public member function of std::ranges::view_interface<D>)
cend returns a sentinel for the constant iterator of the range.
(C++23) (public member function of std::ranges::view_interface<D>)
operator bool returns whether the derived view is not empty. Provided if
(C++20) ranges::empty is applicable to it.
(public member function of std::ranges::view_interface<D>)
front returns the first element in the derived view. Provided if it
(C++20) satisfies forward_range.
(public member function of std::ranges::view_interface<D>)

Nested classes

outer_iterator the iterator type
(C++20) (exposition-only member class template*)
inner_iterator the iterator type of the inner range
(C++20) (exposition-only member class template*)

Deduction guides

Notes¶

The name lazy_split_view is introduced by the post-C++20 defect report P2210R2. It
has the same lazy mechanism as that of the old split_view before change.

Example¶

// Run this code

#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>

auto print = [](auto const& view)
{
// `view` is of std::views::lazy_split_view::__outer_iterator::value_type

for (std::cout << "{ "; const auto element : view)
std::cout << element << ' ';
std::cout << "} ";
};

int main()
{
constexpr static auto source = {0, 1, 0, 2, 3, 0, 4, 5, 6, 0, 7, 8, 9};
constexpr int delimiter{0};
constexpr std::ranges::lazy_split_view outer_view{source, delimiter};
std::cout << "splits[" << std::ranges::distance(outer_view) << "]: ";
for (auto const& inner_view: outer_view)
print(inner_view);

constexpr std::string_view hello{"Hello C++ 20 !"};
std::cout << "\n" "substrings: ";
std::ranges::for_each(hello | std::views::lazy_split(' '), print);

constexpr std::string_view text{"Hello-+-C++-+-20-+-!"};
constexpr std::string_view delim{"-+-"};
std::cout << "\n" "substrings: ";
std::ranges::for_each(text | std::views::lazy_split(delim), print);
}

Output:¶

splits[5]: { } { 1 } { 2 3 } { 4 5 6 } { 7 8 9 }
substrings: { H e l l o } { C + + } { 2 0 } { ! }
substrings: { H e l l o } { C + + } { 2 0 } { ! }

Defect reports

The following behavior-changing defect reports were applied retroactively to
previously published C++ standards.

DR Applied to Behavior as published Correct behavior
P2210R2 C++20 the old split_view was too lazy to be moves its functionality to
easily used lazy_split_view

See also¶

ranges::split_view a view over the subranges obtained from splitting another view
views::split using a delimiter
(C++20) (class template) (range adaptor object)
ranges::join_view a view consisting of the sequence obtained from flattening a view
views::join of ranges
(C++20) (class template) (range adaptor object)