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

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

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)

Execution support library (C++26)

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 (C++23)(C++23)     to (C++23)

Dangling iterator handling dangling borrowed_iterator_t borrowed_subrange_t

Range primitives
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 concepts
range borrowed_range    sized_range	common_range view viewable_range	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	constant_range (C++23)

Views
view_interface	subrange

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

Range adaptors
views::all_tviews::all ref_view owning_view as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while concat_viewviews::concat (C++26)(C++26)	drop_viewviews::drop drop_while_viewviews::drop_while join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   lazy_split_viewviews::lazy_split split_viewviews::split views::counted common_viewviews::common	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 objects range_adaptor_closure (C++23)

Range adaptor objects

Helper items
copyable-box movable-box (until C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::split_view

Member functions

split_view::split_view

split_view::base

split_view::begin

split_view::end

split_view::find_next

Nested classes

split_view::iterator

split_view::sentinel

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) RangeAdaptorObject. 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.

Data members

Member name	Definition
base_ (private)	the underlying (adapted) view of type V (exposition-only member object*)
pattern_ (private)	the pattern object that is used as a delimiter to split the underlying view (exposition-only member object*)
cached_begin_ (private)	an optional-like object of type /*non-propagating-cache*/<ranges::subrange<ranges::iterator_t<V>>> that caches the result of the first call to begin() (exposition-only member object*)

Member functions

(constructor)	constructs a split_view (public member function)
base	returns a copy of the underlying (adapted) view (public member function)
begin	returns an iterator to the beginning (public member function)
end	returns an iterator or a sentinel to the end (public member function)
find_next	searches for the next occurrence of the pattern (exposition-only member function*)
Inherited from std::ranges::view_interface
empty	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 (C++23)	returns a constant iterator to the beginning of the range. (public member function of std::ranges::view_interface<D>)
cend (C++23)	returns a sentinel for the constant iterator of the range. (public member function of std::ranges::view_interface<D>)
operator bool	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	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	the iterator type (exposition-only member class*)
sentinel	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.

The delimiter pattern generally should not be an ordinary string literal, as it will consider the null terminator to be necessary part of the delimiter; therefore, it is advisable to use a std::string_view literal instead.

Example

Run this code

#include <iomanip>
#include <iostream>
#include <ranges>
#include <string_view>
 
int main()
{
    using std::operator""sv;
    constexpr auto words{"Hello^_^C++^_^20^_^!"sv};
    constexpr auto delim{"^_^"sv};
 
    for (const auto word : std::views::split(words, delim))
        // with string_view's C++23 range constructor:
        std::cout << std::quoted(std::string_view(word)) << ' ';
    std::cout << '\n';
}

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)