std::ranges:: views:: stride, std::ranges:: stride_view

From cppreference.com

Defined in header `<ranges>`
template < ranges:: input_range V > requires ranges:: view < V > class stride_view : public ranges:: view_interface < stride_view < V >>	(1)	(since C++23)
namespace views { inline constexpr /* unspecified / stride = / unspecified */ ; }	(2)	(since C++23)
Call signature
template < ranges:: viewable_range R > constexpr ranges:: view auto stride ( R && r, ranges:: range_difference_t < R > n ) ;		(since C++23)
template < class DifferenceType > constexpr /range adaptor closure/ stride ( DifferenceType && n ) ;		(since C++23)
Helper templates


        stride_view

is a range adaptor that takes a


         view

and a number

and produces a view, that consists of elements of the original view by advancing over n elements at a time. This means that each

^th element of the produced view is


        
         (n * i)

^th element of the original view, for some non-negative index

. The elements of the original view, whose "index" is not a multiple of

, are not present in the produced view.

Let

be the size of the original view. Then the size of produced view is:

( S / n ) + ( S % n ? 1 : 0 ) , if S >= n ; otherwise,
1 , if S > 0 ; otherwise,
0 , and the resulting view is empty.

2) The name views :: stride denotes a RangeAdaptorObject . Given subexpressions e and n , the expression views :: stride ( e, n ) is expression-equivalent to stride_view ( e, n ) .

The

must be greater than 0 , otherwise the behavior is undefined.

stride_view always models input_range , and models forward_range , bidirectional_range , random_access_range , and/or sized_range , if adapted view type V models the corresponding concept. stride_view < V > models common_range whenever the underlying view V does.

Data members

Member object	Definition
`base_` (private)	The underlying `view` of type `V` . ( exposition-only member object* )
`stride_` (private)	The size object (the "stride") of type ranges:: range_difference_t < V > . ( exposition-only member object* )

Member functions

(constructor)	constructs a `stride_view` (public member function)
stride (C++23)	returns the stored stride value (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)
size	returns the number of elements. Provided only if the underlying (adapted) range satisfies `sized_range` . (public 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>` )
back	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>` )
operator[]	returns the `n` ^th element in the derived view. Provided if it satisfies `random_access_range` . (public member function of `std::ranges::view_interface<D>` )

Deduction guides

Nested classes

iterator

(C++23)

the iterator type
( exposition-only member class template* )

Helper templates

template < class V > constexpr bool ranges:: enable_borrowed_range < stride_view < V >> = ranges:: enable_borrowed_range < V > ;		(since C++23)

This specialization of ranges::enable_borrowed_range makes stride_view satisfy borrowed_range when the underlying view satisfies it.

Notes

Feature-test macro	Value	Std	Feature
`__cpp_lib_ranges_stride`	202207L	(C++23)	`std::ranges::stride_view`

Example

Run this code

#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>
using namespace std::literals;
 
void print(std::ranges::viewable_range auto&& v, std::string_view separator = " ")
{
    for (auto const& x : v)
        std::cout << x << separator;
    std::cout << '\n';
}
 
int main()
{
    print(std::views::iota(1, 13) | std::views::stride(3));
    print(std::views::iota(1, 13) | std::views::stride(3) | std::views::reverse);
    print(std::views::iota(1, 13) | std::views::reverse | std::views::stride(3));
 
    print("0x0!133713337*x//42/A$@"sv | std::views::stride(0B11) |
          std::views::transform([](char O) -> char { return 0100 | O; }),
          "");
}

Output:

1 4 7 10
10 7 4 1
12 9 6 3
password

References

C++23 standard (ISO/IEC 14882:2024):

26.7.31 Stride view [range.stride]

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

Member functions
stride_view::stride_view
stride_view::base
stride_view::stride
stride_view::begin
stride_view::end
stride_view::size
Deduction guides
Iterator
Member functions
stride_view:: iterator :: iterator
stride_view:: iterator ::base
stride_view:: iterator ::operator*
stride_view:: iterator ::operator[]
stride_view:: iterator ::operator++ stride_view:: iterator ::operator++ (int) stride_view:: iterator ::operator-- stride_view:: iterator ::operator-- (int) stride_view:: iterator ::operator+= stride_view:: iterator ::operator-=
Non-member functions
operator== (std::default_sentinel_t) operator== (stride_view:: iterator ) operator< (stride_view:: iterator ) operator> (stride_view:: iterator ) operator<= (stride_view:: iterator ) operator>= (stride_view:: iterator ) operator<=> (stride_view:: iterator )
operator+ (stride_view:: iterator ) operator- (stride_view:: iterator )
iter_move (stride_view:: iterator )
iter_swap (stride_view:: iterator )

ranges::slide_view views::slide (C++23)	a `view` whose M ^th element is a `view` over the M ^th through (M + N - 1) ^th elements of another `view` (class template) (range adaptor object)
ranges::chunk_view views::chunk (C++23)	a range of `view` s that are `N` -sized non-overlapping successive chunks of the elements of another `view` (class template) (range adaptor object)
ranges::adjacent_view views::adjacent (C++23)	a `view` consisting of tuples of references to adjacent elements of the adapted view (class template) (range adaptor object)
ranges::filter_view views::filter (C++20)	a `view` that consists of the elements of a `range` that satisfies a predicate (class template) (range adaptor object)