std::ranges...::split_view(3)

📦 version 2024.07.05, in nixpkgs unstable, opensuse-leap 16.0

💅 std::ranges...::split_view(3) 💅

okay so you're on the C++ Standard Libary manual page for std::ranges...::split_view(3) — yes, “Libary” is literally how the header spells it, and honestly? iconic typo energy 😭. This page is your group chat for splitting a view on a delimiter, bestie. Periodt. 💖

NAME

std::ranges::views::split,std::ranges::split_view — the split besties: the range adaptor and the view that does the actual splitting. No cap, they're a package deal. 🫶

Synopsis ✨

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)

split_view takes a view and a delimiter, and splits the view into subranges on the delimiter. slay.
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. literally the whole concept glow-up, iykyk. ✨

Member functions 🎀

Here's the whole roster, no skips:

constructor — constructs a 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)
find_next — searches for the next occurrence of the pattern. (C++20) (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. (C++20) (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 ranges::empty is applicable to it. (C++20) (public member function of std::ranges::view_interface<D>)
front — returns the first element in the derived view. Provided if it satisfies forward_range. (C++20) (public member function of std::ranges::view_interface<D>)

Nested classes 🌸

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

Deduction guides 🧚

literally nothing listed here in the source, so I'm not inventing deductions, bestie 🫶

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 way that whole redesign happened? main character energy fr fr. 👑

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. That's a real warning, not a vibe — do not let the null terminator crash the party 💀.

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: P2210R2 — Applied to: C++20 — Behavior as published: the old split_view was too lazy to be easily used — Correct behavior: it is redesigned.

std::ranges...::split_view(3)