From Jason Turner

[range.enumerate]

C++23 → Trunk 3.5 KB 25 lines
Current Draft | LaTeX Source
Archived: C++23
Markdown: C++23 | Trunk
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpqjgp5egc/{from.md → to.md} +12 -7
tmp/tmpqjgp5egc/{from.md → to.md} RENAMED
@@ -3,13 +3,13 @@
3
  #### Overview <a id="range.enumerate.overview">[[range.enumerate.overview]]</a>
4
 
5
  `enumerate_view` is a view whose elements represent both the position
6
  and value from a sequence of elements.
7
 
8
- The name `views::enumerate` denotes a range adaptor object. Given a
9
- subexpression `E`, the expression `views::enumerate(E)` is
10
- expression-equivalent to
11
  `enumerate_view<views::all_t<decltype((E))>>(E)`.
12
 
13
  [*Example 1*:
14
 
15
  ``` cpp
@@ -45,27 +45,32 @@ namespace std::ranges {
45
  { return iterator<false>(ranges::begin(base_), 0); }
46
  constexpr auto begin() const requires range-with-movable-references<const V>
47
  { return iterator<true>(ranges::begin(base_), 0); }
48
 
49
  constexpr auto end() requires (!simple-view<V>) {
50
- if constexpr (common_range<V> && sized_range<V>)
51
  return iterator<false>(ranges::end(base_), ranges::distance(base_));
52
  else
53
  return sentinel<false>(ranges::end(base_));
54
  }
55
  constexpr auto end() const requires range-with-movable-references<const V> {
56
- if constexpr (common_range<const V> && sized_range<const V>)
57
  return iterator<true>(ranges::end(base_), ranges::distance(base_));
58
  else
59
  return sentinel<true>(ranges::end(base_));
60
  }
61
 
62
  constexpr auto size() requires sized_range<V>
63
  { return ranges::size(base_); }
64
  constexpr auto size() const requires sized_range<const V>
65
  { return ranges::size(base_); }
66
 
 
 
 
 
 
67
  constexpr V base() const & requires copy_constructible<V> { return base_; }
68
  constexpr V base() && { return std::move(base_); }
69
  };
70
 
71
  template<class R>
@@ -141,11 +146,11 @@ namespace std::ranges {
141
  requires random_access_range<Base>;
142
  friend constexpr iterator operator+(difference_type x, const iterator& y)
143
  requires random_access_range<Base>;
144
  friend constexpr iterator operator-(const iterator& x, difference_type y)
145
  requires random_access_range<Base>;
146
- friend constexpr difference_type operator-(const iterator& x, const iterator& y);
147
 
148
  friend constexpr auto iter_move(const iterator& i)
149
  noexcept(noexcept(ranges::iter_move(i.current_)) &&
150
  is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>) {
151
  return tuple<difference_type,
@@ -323,11 +328,11 @@ auto temp = x;
323
  temp -= y;
324
  return temp;
325
  ```
326
 
327
  ``` cpp
328
- friend constexpr difference_type operator-(const iterator& x, const iterator& y);
329
  ```
330
 
331
  *Effects:* Equivalent to: `return x.`*`pos_`*` - y.`*`pos_`*`;`
332
 
333
  #### Class template `enumerate_view::sentinel` <a id="range.enumerate.sentinel">[[range.enumerate.sentinel]]</a>
 
3
  #### Overview <a id="range.enumerate.overview">[[range.enumerate.overview]]</a>
4
 
5
  `enumerate_view` is a view whose elements represent both the position
6
  and value from a sequence of elements.
7
 
8
+ The name `views::enumerate` denotes a range adaptor object
9
+ [[range.adaptor.object]]. Given a subexpression `E`, the expression
10
+ `views::enumerate(E)` is expression-equivalent to
11
  `enumerate_view<views::all_t<decltype((E))>>(E)`.
12
 
13
  [*Example 1*:
14
 
15
  ``` cpp
 
45
  { return iterator<false>(ranges::begin(base_), 0); }
46
  constexpr auto begin() const requires range-with-movable-references<const V>
47
  { return iterator<true>(ranges::begin(base_), 0); }
48
 
49
  constexpr auto end() requires (!simple-view<V>) {
50
+ if constexpr (forward_range<V> && common_range<V> && sized_range<V>)
51
  return iterator<false>(ranges::end(base_), ranges::distance(base_));
52
  else
53
  return sentinel<false>(ranges::end(base_));
54
  }
55
  constexpr auto end() const requires range-with-movable-references<const V> {
56
+ if constexpr (forward_range<const V> && common_range<const V> && sized_range<const V>)
57
  return iterator<true>(ranges::end(base_), ranges::distance(base_));
58
  else
59
  return sentinel<true>(ranges::end(base_));
60
  }
61
 
62
  constexpr auto size() requires sized_range<V>
63
  { return ranges::size(base_); }
64
  constexpr auto size() const requires sized_range<const V>
65
  { return ranges::size(base_); }
66
 
67
+ constexpr auto reserve_hint() requires approximately_sized_range<V>
68
+ { return ranges::reserve_hint(base_); }
69
+ constexpr auto reserve_hint() const requires approximately_sized_range<const V>
70
+ { return ranges::reserve_hint(base_); }
71
+
72
  constexpr V base() const & requires copy_constructible<V> { return base_; }
73
  constexpr V base() && { return std::move(base_); }
74
  };
75
 
76
  template<class R>
 
146
  requires random_access_range<Base>;
147
  friend constexpr iterator operator+(difference_type x, const iterator& y)
148
  requires random_access_range<Base>;
149
  friend constexpr iterator operator-(const iterator& x, difference_type y)
150
  requires random_access_range<Base>;
151
+ friend constexpr difference_type operator-(const iterator& x, const iterator& y) noexcept;
152
 
153
  friend constexpr auto iter_move(const iterator& i)
154
  noexcept(noexcept(ranges::iter_move(i.current_)) &&
155
  is_nothrow_move_constructible_v<range_rvalue_reference_t<Base>>) {
156
  return tuple<difference_type,
 
328
  temp -= y;
329
  return temp;
330
  ```
331
 
332
  ``` cpp
333
+ friend constexpr difference_type operator-(const iterator& x, const iterator& y) noexcept;
334
  ```
335
 
336
  *Effects:* Equivalent to: `return x.`*`pos_`*` - y.`*`pos_`*`;`
337
 
338
  #### Class template `enumerate_view::sentinel` <a id="range.enumerate.sentinel">[[range.enumerate.sentinel]]</a>