From Jason Turner

[range.single]

C++20 → C++23 2.8 KB 30 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpj2ej1r2h/{from.md → to.md} +15 -11
tmp/tmpj2ej1r2h/{from.md → to.md} RENAMED
@@ -1,57 +1,60 @@
1
  ### Single view <a id="range.single">[[range.single]]</a>
2
 
3
  #### Overview <a id="range.single.overview">[[range.single.overview]]</a>
4
 
5
- `single_view` produces a `view` that contains exactly one element of a
6
  specified value.
7
 
8
  The name `views::single` denotes a customization point object
9
  [[customization.point.object]]. Given a subexpression `E`, the
10
  expression `views::single(E)` is expression-equivalent to
11
- `single_view{E}`.
12
 
13
  [*Example 1*:
14
 
15
  ``` cpp
16
- single_view s{4};
17
- for (int i : s)
18
  cout << i; // prints 4
19
  ```
20
 
21
  — *end example*]
22
 
23
  #### Class template `single_view` <a id="range.single.view">[[range.single.view]]</a>
24
 
25
  ``` cpp
26
  namespace std::ranges {
27
- template<copy_constructible T>
28
  requires is_object_v<T>
29
  class single_view : public view_interface<single_view<T>> {
30
  private:
31
- semiregular-box<T> value_; // exposition only{} (see [range.semi.wrap])
 
32
  public:
33
- single_view() = default;
34
- constexpr explicit single_view(const T& t);
35
  constexpr explicit single_view(T&& t);
36
  template<class... Args>
37
  requires constructible_from<T, Args...>
38
- constexpr single_view(in_place_t, Args&&... args);
39
 
40
  constexpr T* begin() noexcept;
41
  constexpr const T* begin() const noexcept;
42
  constexpr T* end() noexcept;
43
  constexpr const T* end() const noexcept;
44
  static constexpr size_t size() noexcept;
45
  constexpr T* data() noexcept;
46
  constexpr const T* data() const noexcept;
47
  };
 
 
 
48
  }
49
  ```
50
 
51
  ``` cpp
52
- constexpr explicit single_view(const T& t);
53
  ```
54
 
55
  *Effects:* Initializes *value\_* with `t`.
56
 
57
  ``` cpp
@@ -60,11 +63,12 @@ constexpr explicit single_view(T&& t);
60
 
61
  *Effects:* Initializes *value\_* with `std::move(t)`.
62
 
63
  ``` cpp
64
  template<class... Args>
65
- constexpr single_view(in_place_t, Args&&... args);
 
66
  ```
67
 
68
  *Effects:* Initializes *value\_* as if by
69
  *`value_`*`{in_place, std::forward<Args>(args)...}`.
70
 
 
1
  ### Single view <a id="range.single">[[range.single]]</a>
2
 
3
  #### Overview <a id="range.single.overview">[[range.single.overview]]</a>
4
 
5
+ `single_view` produces a view that contains exactly one element of a
6
  specified value.
7
 
8
  The name `views::single` denotes a customization point object
9
  [[customization.point.object]]. Given a subexpression `E`, the
10
  expression `views::single(E)` is expression-equivalent to
11
+ `single_view<decay_t<decltype((E))>>(E)`.
12
 
13
  [*Example 1*:
14
 
15
  ``` cpp
16
+ for (int i : views::single(4))
 
17
  cout << i; // prints 4
18
  ```
19
 
20
  — *end example*]
21
 
22
  #### Class template `single_view` <a id="range.single.view">[[range.single.view]]</a>
23
 
24
  ``` cpp
25
  namespace std::ranges {
26
+ template<move_constructible T>
27
  requires is_object_v<T>
28
  class single_view : public view_interface<single_view<T>> {
29
  private:
30
+ movable-box<T> value_; // exposition only{} (see [range.move.wrap])
31
+
32
  public:
33
+ single_view() requires default_initializable<T> = default;
34
+ constexpr explicit single_view(const T& t) requires copy_constructible<T>;
35
  constexpr explicit single_view(T&& t);
36
  template<class... Args>
37
  requires constructible_from<T, Args...>
38
+ constexpr explicit single_view(in_place_t, Args&&... args);
39
 
40
  constexpr T* begin() noexcept;
41
  constexpr const T* begin() const noexcept;
42
  constexpr T* end() noexcept;
43
  constexpr const T* end() const noexcept;
44
  static constexpr size_t size() noexcept;
45
  constexpr T* data() noexcept;
46
  constexpr const T* data() const noexcept;
47
  };
48
+
49
+ template<class T>
50
+ single_view(T) -> single_view<T>;
51
  }
52
  ```
53
 
54
  ``` cpp
55
+ constexpr explicit single_view(const T& t) requires copy_constructible<T>;
56
  ```
57
 
58
  *Effects:* Initializes *value\_* with `t`.
59
 
60
  ``` cpp
 
63
 
64
  *Effects:* Initializes *value\_* with `std::move(t)`.
65
 
66
  ``` cpp
67
  template<class... Args>
68
+ requires constructible_from<T, Args...>
69
+ constexpr explicit single_view(in_place_t, Args&&... args);
70
  ```
71
 
72
  *Effects:* Initializes *value\_* as if by
73
  *`value_`*`{in_place, std::forward<Args>(args)...}`.
74