std::ranges::views::split, std::ranges::split_view

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++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
to (C++23)
Range primitives
range_size_trange_difference_t range_value_t	range_reference_trange_const_reference_trange_rvalue_reference_t   (C++23)	iterator_tconst_iterator_tsentinel_t (C++23)
Dangling iterator handling
dangling	borrowed_iterator_t	borrowed_subrange_t
Range concepts
range borrowed_range    sized_range constant_range (C++23)	common_range view viewable_range	input_range output_range forward_range	bidirectional_range random_access_range contiguous_range
Views
view_interface	subrange
Factories
empty_viewviews::empty iota_viewviews::iota	single_viewviews::single basic_istream_viewviews::istream	repeat_viewviews::repeat (C++23)(C++23)
Adaptors
ref_view views::all_tviews::all common_viewviews::common owning_view views::counted reverse_viewviews::reverse zip_viewviews::zip (C++23)(C++23) as_const_viewviews::as_const (C++23)(C++23) as_rvalue_viewviews::as_rvalue (C++23)(C++23)	take_viewviews::take take_while_viewviews::take_while drop_viewviews::drop drop_while_viewviews::drop_while zip_transform_viewviews::zip_transform (C++23)(C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23)   cartesian_product_viewviews::cartesian_product (C++23)(C++23)	elements_viewviews::elements keys_viewviews::keys values_viewviews::values transform_viewviews::transform adjacent_viewviews::adjacent (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) stride_viewviews::stride (C++23)(C++23)	filter_viewviews::filter join_viewviews::join split_viewviews::split lazy_split_viewviews::lazy_split join_with_viewviews::join_with (C++23)(C++23) chunk_viewviews::chunk (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23)
Range adaptor objects
Range adaptor closure objects
Helper items
copyable-box	simple-view

 

std::ranges::split_view

Member functions

split_view::split_view (C++20)

split_view::base (C++20)

split_view::begin (C++20)

split_view::end (C++20)

Nested classes

split_view::iterator (C++20)

split_view::sentinel (C++20)

Deduction guides

 

Defined in header <ranges>
template< ranges::forward_range V, ranges::forward_range Pattern > requires ranges::view<V> && ranges::view<Pattern> &&   std::indirectly_comparable<ranges::iterator_t<V>, ranges::iterator_t<Pattern>,                              ranges::equal_to> class split_view : public ranges::view_interface<split_view<V, Pattern>>	(1)	(since C++20)
namespace views {     inline constexpr /*unspecified*/ split = /*unspecified*/; }	(2)	(since C++20)
Call signature
template< ranges::viewable_range R, class Pattern >     requires /* see below */ constexpr ranges::view auto split( R&& r, Pattern&& pattern );		(since C++20)
template< class Pattern > constexpr /*range adaptor closure*/ split( Pattern&& pattern );		(since C++20)

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

2) Ranges adaptor object. The expression views::split(e, p) is expression-equivalent to split_view(e, p) for any suitable subexpressions e and p.

split_view models the concepts forward_range, and common_range when the underlying view V models respective concepts.

The inner range (ranges::range_reference_t<split_view>) is a ranges::subrange<ranges::iterator_t<V>>, which models common_range, models sized_range when ranges::iterator_t<V> models std::sized_sentinel_for<ranges::iterator_t<V>>, and models contiguous_range, random_access_range, bidirectional_range, and forward_range when V models respective concepts.

Expression-equivalent

Expression e is expression-equivalent to expression f, if

• e and f have the same effects, and
• either both are constant subexpressions or else neither is a constant subexpression, and
• either both are potentially-throwing or else neither is potentially-throwing (i.e. noexcept(e) == noexcept(f)).

Data members

Typical implementations of split_view hold three non-static data members:

• the underlying view of type V (shown here as base_ for exposition only), and
• the pattern (shown here as pattern_ for exposition only) that is used as a delimiter to split the underlying view.
• an object equivalent to std::optional<ranges::subrange<ranges::iterator_t<V>>> (shown here as cached_begin_ for exposition only) that caches the result of a first call to begin().

Member functions

(constructor) (C++20)	constructs a split_view (public member function)
base (C++20)	returns a copy of the underlying (adapted) view (public member function)
begin (C++20)	returns an iterator to the beginning (public member function)
end (C++20)	returns an iterator or a sentinel to the end (public member function)
find_next (C++20)	searches for the next occurrence of the pattern (exposition-only member function)
Inherited from std::ranges::view_interface
empty (C++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>)
operator bool (C++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 (C++20)	Returns the first element in the derived view. Provided if it satisfies forward_range. (public member function of std::ranges::view_interface<D>)

Nested classes

iterator (C++20)	the iterator type (exposition-only member class)
sentinel (C++20)	the sentinel type (exposition-only member class)

Notes

Before P2210R2, split_view used a lazy mechanism for splitting, and thus could not keep the bidirectional, random access, or contiguous properties of the underlying view, or make the iterator type of the inner range same as that of the underlying view. Consequently, it is redesigned by P2210R2, and the lazy mechanism is moved to lazy_split_view.

Example

A link to check the example: wandbox

Run this code

#include <iostream>
#include <iomanip>
#include <ranges>
#include <string_view>
 
int main() {
    constexpr std::string_view words{"Hello-_-C++-_-20-_-!"};
    constexpr std::string_view delim{"-_-"};
    for (const auto word : std::views::split(words, delim)) {
        std::cout << std::quoted(std::string_view(word.begin(), word.end())) << ' ';
    }
}

Output:

"Hello" "C++" "20" "!"

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 easily used	it is redesigned

See also

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