Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/ranges/split view"

From cppreference.com
< cpp‎ | ranges
(→‎Example: relying on that implicit conversion is unnecessarily confusing (especially since this is a DR))
Line 78: Line 78:
  
 
int main() {
 
int main() {
−
     constexpr std::string_view words{"Hello-_-C++-_-23-_-!"};
+
     constexpr std::string_view words{"Hello-_-C++-_-20-_-!"};
 
     constexpr std::string_view delim{"-_-"};
 
     constexpr std::string_view delim{"-_-"};
−
     for (const std::string_view word : std::views::split(words, delim)) {
+
     for (const auto word : std::views::split(words, delim)) {
−
         std::cout << std::quoted(word) << ' ';
+
         std::cout << std::quoted(std::string_view(word.begin(), word.end())) << ' ';
 
     }
 
     }
 
}
 
}
 
| output=
 
| output=
−
"Hello" "C++" "23" "!"
+
"Hello" "C++" "20" "!"
 
}}
 
}}
  

Revision as of 10:57, 24 November 2021

 
C++
 
Ranges library
Range adaptors
 
std::ranges::split_view
 
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 );
template< class Pattern >
constexpr /*range adaptor closure*/ split( Pattern&& pattern );


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.

Contents

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

 constructs a split_view
(public member function) [edit]
returns a copy of the underlying (adapted) view
(public member function) [edit]
returns an iterator to the beginning
(public member function) [edit]
returns an iterator or a sentinel to the end
(public member function) [edit]
(C++20)
 searches for the next occurrence of the pattern
(exposition-only member function*)
Inherited from std::ranges::view_interface
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>) [edit]
(C++23)
 returns a constant iterator to the beginning of the range.
(public member function of std::ranges::view_interface<D>) [edit]
(C++23)
 returns a sentinel for the constant iterator of the range.
(public member function of std::ranges::view_interface<D>) [edit]
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>) [edit]
returns the first element in the derived view. Provided if it satisfies forward_range.
(public member function of std::ranges::view_interface<D>) [edit]

Nested classes

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

Deduction guides

Notes

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" "!"

See also

(C++20)
 a view over the subranges obtained from splitting another view using a delimiter
(class template) (range adaptor object)[edit]
(C++20)
 a view consisting of the sequence obtained from flattening a view of ranges
(class template) (range adaptor object)[edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/ranges/split_view&oldid=135538"