std::ranges::views::slide, std::ranges::slide_view
Defined in header <ranges>
|
||
template< ranges::forward_range V > requires ranges::view<V> |
(1) | (since C++23) |
namespace views { inline constexpr /* unspecified */ slide = /* unspecified */; |
(2) | (since C++23) |
Call signature |
||
template< ranges::viewable_range R > constexpr ranges::view auto slide( R&& r, ranges::range_difference_t<V> n ); |
(since C++23) | |
template< ranges::forward_range V > requires ranges::view<V> |
(since C++23) | |
Helper concepts |
||
template< class V > concept __slide_caches_nothing = // exposition only |
(3) | (since C++23) |
template< class V > concept __slide_caches_last = // exposition only |
(4) | (since C++23) |
template< class V > concept __slide_caches_first = // exposition only |
(5) | (since C++23) |
Helper templates |
||
slide_view
is a range adaptor that takes a view
and a number n
and produces a view whose mth element (a "window") is a view over the mth through (m + n - 1)th elements of the original view.S
be the size of the original view. Then the size of produced view is:
- S - n + 1, if
S >= n
, - 0 otherwise, and the resulting view is empty.
If the n
is not greater than 0 the behavior is undefined.
slide_view
always models forward_range
, and models bidirectional_range
, random_access_range
, or sized_range
if adapted view
type models the corresponding concept.
Contents |
[edit] 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)).
[edit] Data members
Typical implementations of slide_view
hold from two to four non-static data members:
- the underlying
view
of typeV
(shown here asbase_
for exposition only), - the "window size" of type ranges::range_difference_t<V> (shown here as
n_
for exposition only). - the std::optional-like object (shown here as
cached_begin_
for exposition only). May be present only if V models the__slide_caches_first
helper concept (4). - the std::optional-like object (shown here as
cached_end_
for exposition only). May be present only if V models the__slide_caches_last
helper concept (5).
[edit] Member functions
(C++23) |
constructs a slide_view (public member function) |
(C++23) |
returns an iterator to the beginning (public member function) |
(C++23) |
returns an iterator or a sentinel to the end (public member function) |
(C++23) |
returns the number of elements. Provided only if the underlying (adapted) range satisfies sized_range . (public member function) |
Inherited from std::ranges::view_interface | |
(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> )
|
(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> )
|
(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> )
|
(C++20) |
Returns the last element in the derived view. Provided if it satisfies bidirectional_range and common_range . (public member function of std::ranges::view_interface<D> )
|
(C++20) |
Returns the nth element in the derived view. Provided if it satisfies random_access_range . (public member function of std::ranges::view_interface<D> )
|
[edit] Deduction guides
[edit] Nested classes
(C++23) |
the iterator type (exposition-only member class template) |
(C++23) |
the sentinel type used when slide_view is not a common_range (exposition-only member class template) |
[edit] Helper templates
template< class V > inline constexpr bool ranges::enable_borrowed_range<slide_view<V>> = |
(since C++23) | |
This specialization of ranges::enable_borrowed_range makes slide_view
satisfy borrowed_range
when the underlying view satisfies it.
[edit] Notes
There is a similarity between ranges::adjacent_view and ranges::slide_view — they both produce a "sliding window" of the size N
, and, given a view
of the size S
, where S >= N > 0
, they both will have the same size: S - N + 1
. The difference between these view
adaptors are:
View adaptor | value_type |
The window size N
|
---|---|---|
ranges::adjacent_view | a tuple-like object | a template parameter |
ranges::slide_view | a range |
a runtime parameter |
Feature-test macro | Value | Std | Comment |
---|---|---|---|
__cpp_lib_ranges_slide |
202202L | (C++23) | std::ranges::slide_view
|
[edit] Example
A link to test: Compiler Explorer.
#include <algorithm> #include <iostream> #include <ranges> auto print_subrange = [](std::ranges::viewable_range auto&& r) { std::cout << "["; for (int pos{}; auto elem : r) std::cout << (pos++ ? " " : "") << elem; std::cout << "] "; }; int main() { const auto v = {1, 2, 3, 4, 5, 6}; for (const unsigned width : std::views::iota(1U, 1U + v.size())) { auto const windows = v | std::views::slide(width); std::cout << "All sliding windows of width " << width << ": "; std::ranges::for_each(windows, print_subrange); std::cout << '\n'; } }
Output:
All sliding windows of width 1: [1] [2] [3] [4] [5] [6] All sliding windows of width 2: [1 2] [2 3] [3 4] [4 5] [5 6] All sliding windows of width 3: [1 2 3] [2 3 4] [3 4 5] [4 5 6] All sliding windows of width 4: [1 2 3 4] [2 3 4 5] [3 4 5 6] All sliding windows of width 5: [1 2 3 4 5] [2 3 4 5 6] All sliding windows of width 6: [1 2 3 4 5 6]
[edit] References
- C++23 standard (ISO/IEC 14882:2023):
- 26.7.28 Slide view [range.slide]
[edit] See also
a view consisting of tuples of references to adjacent elements of the adapted view (class template) (range adaptor object) | |
a range of view s that are N -sized non-overlapping successive chunks of the elements of another view (class template) (range adaptor object) |