cppdraft_translate/cppdraft/range/adjacent.md

[range.adjacent]

25 Ranges library [ranges]

25.7 Range adaptors [range.adaptors]

25.7.27 Adjacent view [range.adjacent]

25.7.27.1 Overview [range.adjacent.overview]

1

#

adjacent_view takes a view and produces a view whose Mth element is a tuple of references to the Mth through (M+N−1)th elements of the original view.

If the original view has fewer than N elements, the resulting view is empty.

2

#

The name views​::​adjacent denotes a range adaptor object ([range.adaptor.object]).

Given a subexpression E and a constant expression N, the expression views​::​adjacent(E) is expression-equivalent to

• (2.1)

((void)E, auto(views​::​empty<tuple<>>)) if N is equal to 0 anddecltype((E)) models forward_range,

• (2.2)

otherwise, adjacent_view<views​::​all_t<decltype((E))>, N>(E).

[Example 1: vector v = {1, 2, 3, 4};

for (auto i : v | views::adjacent<2>) { cout << "(" << std::get<0>(i) << ", " << std::get<1>(i) << ") "; // prints (1, 2) (2, 3) (3, 4)} — end example]

3

#

Define REPEAT(T, N) as a pack of N types, each of which denotes the same type as T.

25.7.27.2 Class template adjacent_view [range.adjacent.view]

🔗

namespace std::ranges {template<forward_range V, size_t N>requires view && (N > 0)class adjacent_view : public view_interface<adjacent_view<V, N>> { V base_ = V(); // exposition only// [range.adjacent.iterator], class template adjacent_view​::​iteratortemplate class iterator; // exposition only// [range.adjacent.sentinel], class template adjacent_view​::​sentineltemplate class sentinel; // exposition onlystruct as-sentinel{}; // exposition onlypublic: adjacent_view() requires default_initializable = default; constexpr explicit adjacent_view(V base); constexpr V base() const & requires copy_constructible { return base_; }constexpr V base() && { return std::move(base_); }constexpr auto begin() requires () {return iterator(ranges::begin(base_), ranges::end(base_)); }constexpr auto begin() const requires range {return iterator(ranges::begin(base_), ranges::end(base_)); }constexpr auto end() requires () {if constexpr (common_range) {return iterator(as-sentinel{}, ranges::begin(base_), ranges::end(base_)); } else {return sentinel(ranges::end(base_)); }}constexpr auto end() const requires range {if constexpr (common_range) {return iterator(as-sentinel{}, ranges::begin(base_), ranges::end(base_)); } else {return sentinel(ranges::end(base_)); }}constexpr auto size() requires sized_range; constexpr auto size() const requires sized_range; constexpr auto reserve_hint() requires approximately_sized_range; constexpr auto reserve_hint() const requires approximately_sized_range; };}

🔗

constexpr explicit adjacent_view(V base);

1

#

Effects: Initializes base_ with std​::​move(base).

🔗

constexpr auto size() requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<V>; constexpr auto size() const requires [sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<const V>;

2

#

Effects: Equivalent to:using ST = decltype(ranges::size(base_));using CT = common_type_t<ST, size_t>;auto sz = static_cast(ranges::size(base_)); sz -= std::min(sz, N - 1);return static_cast(sz);

🔗

constexpr auto reserve_hint() requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<V>; constexpr auto reserve_hint() const requires [approximately_sized_range](range.approximately.sized#concept:approximately_sized_range "25.4.3 Approximately sized ranges [range.approximately.sized]")<const V>;

3

#

Effects: Equivalent to:using DT = range_difference_t<decltype((base_))>;using CT = common_type_t<DT, size_t>;auto sz = static_cast(ranges::reserve_hint(base_)); sz -= std::min(sz, N - 1);return to-unsigned-like(sz);

25.7.27.3 Class template adjacent_view​::​iterator [range.adjacent.iterator]

🔗

namespace std::ranges {template<forward_range V, size_t N>requires view && (N > 0)templateclass adjacent_view<V, N>::iterator {using Base = maybe-const<Const, V>; // exposition only array<iterator_t<Base>, N> current_ = array<iterator_t<Base>, N>(); // exposition onlyconstexpr iterator(iterator_t<Base> first, sentinel_t<Base> last); // exposition onlyconstexpr iterator(as-sentinel, iterator_t<Base> first, iterator_t<Base> last); // exposition onlypublic:using iterator_category = input_iterator_tag; using iterator_concept = see below; using value_type = tuple<REPEAT(range_value_t<Base>, N)...>; using difference_type = range_difference_t<Base>; iterator() = default; constexpr iterator(iterator i)requires Const && convertible_to<iterator_t, iterator_t<Base>>; constexpr auto operator*() const; constexpr iterator& operator++(); constexpr iterator operator++(int); constexpr iterator& operator--() requires bidirectional_range<Base>; constexpr iterator operator--(int) requires bidirectional_range<Base>; constexpr iterator& operator+=(difference_type x)requires random_access_range<Base>; constexpr iterator& operator-=(difference_type x)requires random_access_range<Base>; constexpr auto operator[](difference_type n) constrequires random_access_range<Base>; friend constexpr bool operator==(const iterator& x, const iterator& y); 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& i, difference_type n)requires random_access_range<Base>; friend constexpr iterator operator+(difference_type n, const iterator& i)requires random_access_range<Base>; friend constexpr iterator operator-(const iterator& i, 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 auto iter_move(const iterator& i) noexcept(see below); friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below)requires indirectly_swappable<iterator_t<Base>>; };}

1

#

iterator​::​iterator_concept is defined as follows:

• (1.1)

  If Base models random_access_range, then iterator_concept denotes random_access_iterator_tag.

• (1.2)

  Otherwise, if Base models bidirectional_range, then iterator_concept denotes bidirectional_iterator_tag.

• (1.3)

  Otherwise, iterator_concept denotes forward_iterator_tag.

2

#

If the invocation of any non-const member function of iterator exits via an exception, the iterator acquires a singular value.

🔗

constexpr iterator(iterator_t<Base> first, sentinel_t<Base> last);

3

#

Postconditions: current_[0] == first is true, and for every integer 1≤i<N,current_[i] == ranges​::​next(current_[i-1], 1, last) is true.

🔗

constexpr iterator(as-sentinel, iterator_t<Base> first, iterator_t<Base> last);

4

#

Postconditions: If Base does not model bidirectional_range, each element of current_ is equal to last.

Otherwise, current_[N-1] == last is true, and for every integer 0≤i<(N−1),current_[i] == ranges​::​prev(current_[i+1], 1, first) is true.

🔗

constexpr iterator(iterator<!Const> i) requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<iterator_t<V>, iterator_t<Base>>;

5

#

Effects: Initializes each element of current_ with the corresponding element of i.current_ as an xvalue.

🔗

constexpr auto operator*() const;

6

#

Effects: Equivalent to:return tuple-transform([](auto& i) -> decltype(auto) { return *i; }, current_);

🔗

constexpr iterator& operator++();

7

#

Preconditions: current_.back() is incrementable.

8

#

Postconditions: Each element of current_ is equal to ranges​::​next(i), where i is the value of that element before the call.

9

#

Returns: *this.

🔗

constexpr iterator operator++(int);

10

#

Effects: Equivalent to:auto tmp = *this;++*this;return tmp;

🔗

constexpr iterator& operator--() requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;

11

#

Preconditions: current_.front() is decrementable.

12

#

Postconditions: Each element of current_ is equal to ranges​::​prev(i), where i is the value of that element before the call.

13

#

Returns: *this.

🔗

constexpr iterator operator--(int) requires [bidirectional_range](range.refinements#concept:bidirectional_range "25.4.6 Other range refinements [range.refinements]")<Base>;

14

#

Effects: Equivalent to:auto tmp = *this;--*this;return tmp;

🔗

constexpr iterator& operator+=(difference_type x) requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;

15

#

Preconditions: current_.back() + x has well-defined behavior.

16

#

Postconditions: Each element of current_ is equal to i + x, where i is the value of that element before the call.

17

#

Returns: *this.

🔗

constexpr iterator& operator-=(difference_type x) requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;

18

#

Preconditions: current_.front() - x has well-defined behavior.

19

#

Postconditions: Each element of current_ is equal to i - x, where i is the value of that element before the call.

20

#

Returns: *this.

🔗

constexpr auto operator[](difference_type n) const requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;

21

#

Effects: Equivalent to:return tuple-transform([&](auto& i) -> decltype(auto) { return i[n]; }, current_);

🔗

friend constexpr bool operator==(const iterator& x, const iterator& y);

22

#

Returns: x.current_.back() == y.current_.back().

🔗

friend constexpr bool operator<(const iterator& x, const iterator& y) requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;

23

#

Returns: x.current_.back() < y.current_.back().

🔗

friend constexpr bool operator>(const iterator& x, const iterator& y) requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;

24

#

Effects: Equivalent to: return y < x;

🔗

friend constexpr bool operator<=(const iterator& x, const iterator& y) requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;

25

#

Effects: Equivalent to: return !(y < x);

🔗

friend constexpr bool operator>=(const iterator& x, const iterator& y) requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;

26

#

Effects: Equivalent to: return !(x < y);

🔗

friend constexpr auto operator<=>(const iterator& x, const iterator& y) requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base> && [three_way_comparable](cmp.concept#concept:three_way_comparable "17.12.4 Concept three_­way_­comparable [cmp.concept]")<iterator_t<Base>>;

27

#

Returns: x.current_.back() <=> y.current_.back().

🔗

friend constexpr iterator operator+(const iterator& i, difference_type n) requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>; friend constexpr iterator operator+(difference_type n, const iterator& i) requires [random_access_range](range.refinements#concept:random_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;

28

#

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_access_range "25.4.6 Other range refinements [range.refinements]")<Base>;

29

#

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_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<iterator_t<Base>, iterator_t<Base>>;

30

#

Effects: Equivalent to:return x.current_.back() - y.current_.back();

🔗

friend constexpr auto iter_move(const iterator& i) noexcept(see below);

31

#

Effects: Equivalent to:return tuple-transform(ranges​::​iter_move, i.current_);

32

#

Remarks: The exception specification is equivalent to:noexcept(ranges::iter_move(declval<const iterator_t<Base>&>())) && is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>

🔗

friend constexpr void iter_swap(const iterator& l, const iterator& r) noexcept(see below) requires [indirectly_swappable](alg.req.ind.swap#concept:indirectly_swappable "24.3.7.4 Concept indirectly_­swappable [alg.req.ind.swap]")<iterator_t<Base>>;

33

#

Preconditions: None of the iterators in l.current_ is equal to an iterator in r.current_.

34

#

Effects: For every integer 0≤i<N, performsranges​::​iter_swap(l.current_[i], r.current_[i]).

35

#

Remarks: The exception specification is equivalent to:noexcept(ranges::iter_swap(declval<iterator_t<Base>>(), declval<iterator_t<Base>>()))

25.7.27.4 Class template adjacent_view​::​sentinel [range.adjacent.sentinel]

🔗

namespace std::ranges {template<forward_range V, size_t N>requires view && (N > 0)templateclass adjacent_view<V, N>::sentinel {using Base = maybe-const<Const, V>; // exposition only sentinel_t<Base> end_ = sentinel_t<Base>(); // exposition onlyconstexpr explicit sentinel(sentinel_t<Base> end); // exposition onlypublic:sentinel() = default; constexpr sentinel(sentinel i)requires Const && convertible_to<sentinel_t, sentinel_t<Base>>; templaterequires sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>friend constexpr bool operator==(const iterator& x, const sentinel& y); templaterequires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>friend constexpr range_difference_t<maybe-const<OtherConst, V>>operator-(const iterator& x, const sentinel& y); templaterequires sized_sentinel_for<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>>friend constexpr range_difference_t<maybe-const<OtherConst, V>>operator-(const sentinel& y, const iterator& x); };}

🔗

constexpr explicit sentinel(sentinel_t<Base> end);

1

#

Effects: Initializes end_ with end.

🔗

constexpr sentinel(sentinel<!Const> i) requires Const && [convertible_to](concept.convertible#concept:convertible_to "18.4.4 Concept convertible_­to [concept.convertible]")<sentinel_t<V>, sentinel_t<Base>>;

2

#

Effects: Initializes end_ with std​::​move(i.end_).

🔗

template<bool OtherConst> requires [sentinel_for](iterator.concept.sentinel#concept:sentinel_for "24.3.4.7 Concept sentinel_­for [iterator.concept.sentinel]")<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>> friend constexpr bool operator==(const iterator<OtherConst>& x, const sentinel& y);

3

#

Effects: Equivalent to: return x.current_.back() == y.end_;

🔗

template<bool OtherConst> requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>> friend constexpr range_difference_t<maybe-const<OtherConst, V>> operator-(const iterator<OtherConst>& x, const sentinel& y);

4

#

Effects: Equivalent to: return x.current_.back() - y.end_;

🔗

template<bool OtherConst> requires [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<sentinel_t<Base>, iterator_t<maybe-const<OtherConst, V>>> friend constexpr range_difference_t<maybe-const<OtherConst, V>> operator-(const sentinel& y, const iterator<OtherConst>& x);

5

#

Effects: Equivalent to: return y.end_ - x.current_.back();