[range.stride] (original) (raw)
25.7.32.1 Overview [range.stride.overview]
stride_view presents a view of an underlying sequence, advancing over n elements at a time, as opposed to the usual single-step succession.
Given subexpressions E and N, the expression views::stride(E, N)is expression-equivalent to stride_view(E, N).
[Example 1: auto input = views::iota(0, 12) | views::stride(3); ranges::copy(input, ostream_iterator<int>(cout, " ")); ranges::copy(input | views::reverse, ostream_iterator<int>(cout, " ")); — _end example_]
25.7.32.2 Class template stride_view [range.stride.view]
namespace std::ranges { template<input_range V> requires view<V> class stride_view : public view_interface<stride_view<V>> { V base_; range_difference_t<V> stride_; template<bool> class iterator; public: constexpr explicit stride_view(V base, range_difference_t<V> stride);constexpr V base() const & requires copy_constructible<V> { return base_; } constexpr V base() && { return std::move(base_); } constexpr range_difference_t<V> stride() const noexcept;constexpr auto begin() requires (<V>) { return iterator<false>(this, ranges::begin(base_));} constexpr auto begin() const requires range<const V> { return iterator<true>(this, ranges::begin(base_));} constexpr auto end() requires (
<V>) { if constexpr (common_range<V> && sized_range<V> && forward_range<V>) { auto missing = (stride_ - ranges::distance(base_) % stride_) % stride_;return iterator<false>(this, ranges::end(base_), missing);} else if constexpr (common_range<V> &&
<V>) { return iterator<false>(this, ranges::end(base_));} else { return default_sentinel;} } constexpr auto end() const requires range<const V> { if constexpr (common_range<const V> && sized_range<const V> && forward_range<const V>) { auto missing = (stride_ - ranges::distance(base_) % stride_) % stride_;return iterator<true>(this, ranges::end(base_), missing);} else if constexpr (common_range<const V> &&
<const V>) { return iterator<true>(this, ranges::end(base_));} else { return default_sentinel;} } constexpr auto size() requires sized_range<V>;constexpr auto size() const requires sized_range<const V>;constexpr auto reserve_hint() requires approximately_sized_range<V>;constexpr auto reserve_hint() const requires approximately_sized_range<const V>;};template<class R> stride_view(R&&, range_difference_t<R>) -> stride_view<views::all_t<R>>;}
constexpr stride_view(V base, range_difference_t<V> stride);
Preconditions: stride > 0 is true.
Effects: Initializes base_ with std::move(base) and_stride__ with stride.
constexpr range_difference_t<V> stride() const noexcept;
Effects: Equivalent to:return to-unsigned-like(div-ceil(ranges::distance(base_), stride_));
Effects: Equivalent to:auto s = static_cast<range_difference_t<decltype((_base__))>>(ranges::reserve_hint(base_));return to-unsigned-like(div-ceil(s, stride_));
25.7.32.3 Class template stride_view::iterator [range.stride.iterator]
namespace std::ranges { template<input_range V> requires view<V> template<bool Const> class stride_view<V>::iterator { using Parent = maybe-const<Const, stride_view>; using Base = maybe-const<Const, V>; iterator_t<_Base_> current_ = iterator_t<_Base_>(); sentinel_t<_Base_> end_ = sentinel_t<_Base_>(); range_difference_t<_Base_> stride_ = 0; range_difference_t<_Base_> missing_ = 0; constexpr iterator(Parent* parent, iterator_t<_Base_> current, range_difference_t<_Base_> missing = 0);public: using difference_type = range_difference_t<_Base_>;using value_type = range_value_t<_Base_>;using iterator_concept = see below;using iterator_category = see below; iterator() requires default_initializable<iterator_t<_Base_>> = default;constexpr iterator(iterator<!Const> other) requires Const && convertible_to<iterator_t<V>, iterator_t<_Base_>> && convertible_to<sentinel_t<V>, sentinel_t<_Base_>>;constexpr iterator_t<_Base_> base() &&;constexpr const iterator_t<_Base_>& base() const & noexcept;constexpr decltype(auto) operator*() const { return *current_; } constexpr iterator& operator++();constexpr void operator++(int);constexpr iterator operator++(int) requires forward_range<_Base_>;constexpr iterator& operator--() requires bidirectional_range<_Base_>;constexpr iterator operator--(int) requires bidirectional_range<_Base_>;constexpr iterator& operator+=(difference_type n) requires random_access_range<_Base_>;constexpr iterator& operator-=(difference_type n) requires random_access_range<_Base_>;constexpr decltype(auto) operator[](difference_type n) const requires random_access_range<_Base_> { return *(*this + n); } friend constexpr bool operator==(const iterator& x, default_sentinel_t);friend constexpr bool operator==(const iterator& x, const iterator& y) requires equality_comparable<iterator_t<_Base_>>;friend constexpr bool operator<(const _iterator_& x, const _iterator_& y) requires random_access_range<_Base_>;friend constexpr bool operator>(const iterator& x, const iterator& y) requires random_access_range<_Base_>;friend constexpr bool operator<=(const _iterator_& x, const _iterator_& y) requires random_access_range<_Base_>;friend constexpr bool operator>=(const iterator& x, const iterator& y) requires random_access_range<_Base_>;friend constexpr auto operator<=>(const iterator& x, const iterator& y) requires random_access_range<_Base_> && three_way_comparable<iterator_t<_Base_>>;friend constexpr iterator operator+(const iterator& x, difference_type n) requires random_access_range<_Base_>;friend constexpr iterator operator+(difference_type n, const iterator& x) requires random_access_range<_Base_>;friend constexpr iterator operator-(const iterator& x, difference_type n) requires random_access_range<_Base_>;friend constexpr difference_type operator-(const iterator& x, const iterator& y) requires sized_sentinel_for<iterator_t<_Base_>, iterator_t<_Base_>>;friend constexpr difference_type operator-(default_sentinel_t y, const iterator& x) requires sized_sentinel_for<sentinel_t<_Base_>, iterator_t<_Base_>>;friend constexpr difference_type operator-(const iterator& x, default_sentinel_t y) requires sized_sentinel_for<sentinel_t<_Base_>, iterator_t<_Base_>>;friend constexpr range_rvalue_reference_t<_Base_> iter_move(const iterator& i) noexcept(noexcept(ranges::iter_move(i.current_)));friend constexpr void iter_swap(const iterator& x, const iterator& y) noexcept(noexcept(ranges::iter_swap(x.current_, y.current_))) requires indirectly_swappable<iterator_t<_Base_>>;};}
_iterator_::iterator_concept is defined as follows:
- Otherwise, if Base models bidirectional_range, then iterator_concept denotes bidirectional_iterator_tag.
- Otherwise, if Base models forward_range, then iterator_concept denotes forward_iterator_tag.
- Otherwise, iterator_concept denotes input_iterator_tag.
In that case,_iterator_::iterator_category is defined as follows:
- Let C denote the type iterator_traits<iterator_t<_Base_>>::iterator_category.
- If C modelsderived_from<random_access_iterator_tag>, then iterator_category denotes random_access_iterator_tag.
- Otherwise, iterator_category denotes C.
constexpr _iterator_(_Parent_* parent, iterator_t<_Base_> current, range_difference_t<_Base_> missing = 0);
Effects: Initializes current_ with std::move(current),end_ with ranges::end(parent->base_),stride_ with parent->stride_, and_missing__ with missing.
constexpr _iterator_(_iterator_<!Const> i) requires Const && [convertible_to](concept.convertible#concept:convertible%5Fto "18.4.4 Concept convertible_to [concept.convertible]")<iterator_t<V>, iterator_t<_Base_>> && [convertible_to](concept.convertible#concept:convertible%5Fto "18.4.4 Concept convertible_to [concept.convertible]")<sentinel_t<V>, sentinel_t<_Base_>>;
Effects: Initializes current_ with std::move(i.current_),end_ with std::move(i.end_),stride_ with i.stride_, and_missing__ with i.missing_.
constexpr iterator_t<_Base_> base() &&;
Returns: std::move(current_).
constexpr const iterator_t<_Base_>& base() const & noexcept;
constexpr _iterator_& operator++();
Preconditions: current_ != end_ is true.
Effects: Equivalent to:missing_ = ranges::advance(current_, stride_, end_);return *this;
constexpr void operator++(int);
Effects: Equivalent to ++*this;
Effects: Equivalent to:auto tmp = *this;++*this;return tmp;
Effects: Equivalent to:ranges::advance(current_, missing_ - stride_);missing_ = 0;return *this;
Effects: Equivalent to:auto tmp = *this;--*this;return tmp;
Preconditions: If n is positive,ranges::distance(current_, end_) > stride_ * (n - 1)is true.
[Note 1:
If n is negative, the Effects paragraph implies a precondition.
— _end note_]
Effects: Equivalent to:if (n > 0) { ranges::advance(current_, stride_ * (n - 1));missing_ = ranges::advance(current_, stride_, end_);} else if (n < 0) { ranges::advance(current_, stride_ * n + missing_);missing_ = 0;} return *this;
Effects: Equivalent to: return *this += -x;
friend constexpr bool operator==(const _iterator_& x, default_sentinel_t);
Returns: x.current_ == x.end_.
friend constexpr bool operator==(const _iterator_& x, const _iterator_& y) requires [equality_comparable](concept.equalitycomparable#concept:equality%5Fcomparable "18.5.4 Concept equality_comparable [concept.equalitycomparable]")<iterator_t<_Base_>>;
Returns: x.current_ == y.current_.
friend constexpr bool operator<(const _iterator_& x, const _iterator_& y) requires [random_access_range](range.refinements#concept:random%5Faccess%5Frange "25.4.5 Other range refinements [range.refinements]")<_Base_>;
Returns: x.current_ < y.current_.
friend constexpr bool operator>(const _iterator_& x, const _iterator_& y) requires [random_access_range](range.refinements#concept:random%5Faccess%5Frange "25.4.5 Other range refinements [range.refinements]")<_Base_>;
Effects: Equivalent to: return y < x;
friend constexpr bool operator<=(const _iterator_& x, const _iterator_& y) requires [random_access_range](range.refinements#concept:random%5Faccess%5Frange "25.4.5 Other range refinements [range.refinements]")<_Base_>;
Effects: Equivalent to: return !(y < x);
friend constexpr bool operator>=(const _iterator_& x, const _iterator_& y) requires [random_access_range](range.refinements#concept:random%5Faccess%5Frange "25.4.5 Other range refinements [range.refinements]")<_Base_>;
Effects: Equivalent to: return !(x < y);
Returns: x.current_ <=> y.current_.
friend constexpr _iterator_ operator+(const _iterator_& i, difference_type n) requires [random_access_range](range.refinements#concept:random%5Faccess%5Frange "25.4.5 Other range refinements [range.refinements]")<_Base_>;friend constexpr _iterator_ operator+(difference_type n, const _iterator_& i) requires [random_access_range](range.refinements#concept:random%5Faccess%5Frange "25.4.5 Other range refinements [range.refinements]")<_Base_>;
Effects: Equivalent to:auto r = i; r += n;return r;
friend constexpr _iterator_ operator-(const _iterator_& i, difference_type n) requires [random_access_range](range.refinements#concept:random%5Faccess%5Frange "25.4.5 Other range refinements [range.refinements]")<_Base_>;
Effects: Equivalent to:auto r = i; r -= n;return r;
friend constexpr difference_type operator-(const _iterator_& x, const _iterator_& y) requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized%5Fsentinel%5Ffor "24.3.4.8 Concept sized_sentinel_for [iterator.concept.sizedsentinel]")<iterator_t<_Base_>, iterator_t<_Base_>>;
Returns: Let N be (x.current_ - y.current_).
- If Base models forward_range,(N + x.missing_ - y.missing_) / x.stride_.
- Otherwise, if N is negative, -div-ceil(-N, x.stride_).
- Otherwise, div-ceil(N, x.stride_).
friend constexpr difference_type operator-(default_sentinel_t y, const _iterator_& x) requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized%5Fsentinel%5Ffor "24.3.4.8 Concept sized_sentinel_for [iterator.concept.sizedsentinel]")<sentinel_t<_Base_>, iterator_t<_Base_>>;
Returns: div-ceil(x.end_ - x.current_, x.stride_).
friend constexpr difference_type operator-(const _iterator_& x, default_sentinel_t y) requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized%5Fsentinel%5Ffor "24.3.4.8 Concept sized_sentinel_for [iterator.concept.sizedsentinel]")<sentinel_t<_Base_>, iterator_t<_Base_>>;
Effects: Equivalent to: return -(y - x);
friend constexpr range_rvalue_reference_t<_Base_> iter_move(const _iterator_& i) noexcept(noexcept(ranges::iter_move(i._current_)));
Effects: Equivalent to: return ranges::iter_move(i.current_);
friend constexpr void iter_swap(const _iterator_& x, const _iterator_& y) noexcept(noexcept(ranges::iter_swap(x._current_, y._current_))) requires [indirectly_swappable](alg.req.ind.swap#concept:indirectly%5Fswappable "24.3.7.4 Concept indirectly_swappable [alg.req.ind.swap]")<iterator_t<_Base_>>;
Effects: Equivalent to:ranges::iter_swap(x.current_, y.current_);