tmp/tmpcq2m0mjg/{from.md → to.md}
RENAMED
|
@@ -75,10 +75,16 @@ template<class T>
|
|
| 75 |
requires is_object_v<T>
|
| 76 |
struct cond-value-type<T> {
|
| 77 |
using value_type = remove_cv_t<T>;
|
| 78 |
};
|
| 79 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 80 |
template<class> struct indirectly_readable_traits { };
|
| 81 |
|
| 82 |
template<class T>
|
| 83 |
struct indirectly_readable_traits<T*>
|
| 84 |
: cond-value-type<T> { };
|
|
@@ -91,20 +97,28 @@ struct indirectly_readable_traits<I> {
|
|
| 91 |
|
| 92 |
template<class I>
|
| 93 |
struct indirectly_readable_traits<const I>
|
| 94 |
: indirectly_readable_traits<I> { };
|
| 95 |
|
| 96 |
-
template<
|
| 97 |
-
requires requires { typename T::value_type; }
|
| 98 |
struct indirectly_readable_traits<T>
|
| 99 |
: cond-value-type<typename T::value_type> { };
|
| 100 |
|
| 101 |
-
template<
|
| 102 |
-
requires requires { typename T::element_type; }
|
| 103 |
struct indirectly_readable_traits<T>
|
| 104 |
: cond-value-type<typename T::element_type> { };
|
| 105 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 106 |
template<class T> using iter_value_t = see below;
|
| 107 |
```
|
| 108 |
|
| 109 |
Let R_`I` be `remove_cvref_t<I>`. The type `iter_value_t<I>` denotes
|
| 110 |
|
|
@@ -162,15 +176,15 @@ The definitions in this subclause make use of the following
|
|
| 162 |
exposition-only concepts:
|
| 163 |
|
| 164 |
``` cpp
|
| 165 |
template<class I>
|
| 166 |
concept cpp17-iterator =
|
| 167 |
-
|
| 168 |
{ *i } -> can-reference;
|
| 169 |
{ ++i } -> same_as<I&>;
|
| 170 |
{ *i++ } -> can-reference;
|
| 171 |
-
};
|
| 172 |
|
| 173 |
template<class I>
|
| 174 |
concept cpp17-input-iterator =
|
| 175 |
cpp17-iterator<I> && equality_comparable<I> && requires(I i) {
|
| 176 |
typename incrementable_traits<I>::difference_type;
|
|
@@ -183,11 +197,11 @@ concept cpp17-input-iterator =
|
|
| 183 |
};
|
| 184 |
|
| 185 |
template<class I>
|
| 186 |
concept cpp17-forward-iterator =
|
| 187 |
cpp17-input-iterator<I> && constructible_from<I> &&
|
| 188 |
-
|
| 189 |
same_as<remove_cvref_t<iter_reference_t<I>>,
|
| 190 |
typename indirectly_readable_traits<I>::value_type> &&
|
| 191 |
requires(I i) {
|
| 192 |
{ i++ } -> convertible_to<const I&>;
|
| 193 |
{ *i++ } -> same_as<iter_reference_t<I>>;
|
|
@@ -279,10 +293,16 @@ The members of a specialization `iterator_traits<I>` generated from the
|
|
| 279 |
|
| 280 |
Explicit or partial specializations of `iterator_traits` may have a
|
| 281 |
member type `iterator_concept` that is used to indicate conformance to
|
| 282 |
the iterator concepts [[iterator.concepts]].
|
| 283 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 284 |
`iterator_traits` is specialized for pointers as
|
| 285 |
|
| 286 |
``` cpp
|
| 287 |
namespace std {
|
| 288 |
template<class T>
|
|
@@ -296,11 +316,11 @@ namespace std {
|
|
| 296 |
using reference = T&;
|
| 297 |
};
|
| 298 |
}
|
| 299 |
```
|
| 300 |
|
| 301 |
-
[*Example
|
| 302 |
|
| 303 |
To implement a generic `reverse` function, a C++ program can do the
|
| 304 |
following:
|
| 305 |
|
| 306 |
``` cpp
|
|
|
|
| 75 |
requires is_object_v<T>
|
| 76 |
struct cond-value-type<T> {
|
| 77 |
using value_type = remove_cv_t<T>;
|
| 78 |
};
|
| 79 |
|
| 80 |
+
template<class T>
|
| 81 |
+
concept has-member-value-type = requires { typename T::value_type; }; // exposition only
|
| 82 |
+
|
| 83 |
+
template<class T>
|
| 84 |
+
concept has-member-element-type = requires { typename T::element_type; }; // exposition only
|
| 85 |
+
|
| 86 |
template<class> struct indirectly_readable_traits { };
|
| 87 |
|
| 88 |
template<class T>
|
| 89 |
struct indirectly_readable_traits<T*>
|
| 90 |
: cond-value-type<T> { };
|
|
|
|
| 97 |
|
| 98 |
template<class I>
|
| 99 |
struct indirectly_readable_traits<const I>
|
| 100 |
: indirectly_readable_traits<I> { };
|
| 101 |
|
| 102 |
+
template<has-member-value-type T>
|
|
|
|
| 103 |
struct indirectly_readable_traits<T>
|
| 104 |
: cond-value-type<typename T::value_type> { };
|
| 105 |
|
| 106 |
+
template<has-member-element-type T>
|
|
|
|
| 107 |
struct indirectly_readable_traits<T>
|
| 108 |
: cond-value-type<typename T::element_type> { };
|
| 109 |
|
| 110 |
+
template<has-member-value-type T>
|
| 111 |
+
requires has-member-element-type<T>
|
| 112 |
+
struct indirectly_readable_traits<T> { };
|
| 113 |
+
|
| 114 |
+
template<has-member-value-type T>
|
| 115 |
+
requires has-member-element-type<T> &&
|
| 116 |
+
same_as<remove_cv_t<typename T::element_type>, remove_cv_t<typename T::value_type>>
|
| 117 |
+
struct indirectly_readable_traits<T>
|
| 118 |
+
: cond-value-type<typename T::value_type> { };
|
| 119 |
+
|
| 120 |
template<class T> using iter_value_t = see below;
|
| 121 |
```
|
| 122 |
|
| 123 |
Let R_`I` be `remove_cvref_t<I>`. The type `iter_value_t<I>` denotes
|
| 124 |
|
|
|
|
| 176 |
exposition-only concepts:
|
| 177 |
|
| 178 |
``` cpp
|
| 179 |
template<class I>
|
| 180 |
concept cpp17-iterator =
|
| 181 |
+
requires(I i) {
|
| 182 |
{ *i } -> can-reference;
|
| 183 |
{ ++i } -> same_as<I&>;
|
| 184 |
{ *i++ } -> can-reference;
|
| 185 |
+
} && copyable<I>;
|
| 186 |
|
| 187 |
template<class I>
|
| 188 |
concept cpp17-input-iterator =
|
| 189 |
cpp17-iterator<I> && equality_comparable<I> && requires(I i) {
|
| 190 |
typename incrementable_traits<I>::difference_type;
|
|
|
|
| 197 |
};
|
| 198 |
|
| 199 |
template<class I>
|
| 200 |
concept cpp17-forward-iterator =
|
| 201 |
cpp17-input-iterator<I> && constructible_from<I> &&
|
| 202 |
+
is_reference_v<iter_reference_t<I>> &&
|
| 203 |
same_as<remove_cvref_t<iter_reference_t<I>>,
|
| 204 |
typename indirectly_readable_traits<I>::value_type> &&
|
| 205 |
requires(I i) {
|
| 206 |
{ i++ } -> convertible_to<const I&>;
|
| 207 |
{ *i++ } -> same_as<iter_reference_t<I>>;
|
|
|
|
| 293 |
|
| 294 |
Explicit or partial specializations of `iterator_traits` may have a
|
| 295 |
member type `iterator_concept` that is used to indicate conformance to
|
| 296 |
the iterator concepts [[iterator.concepts]].
|
| 297 |
|
| 298 |
+
[*Example 1*: To indicate conformance to the `input_iterator` concept
|
| 299 |
+
but a lack of conformance to the *Cpp17InputIterator* requirements
|
| 300 |
+
[[input.iterators]], an `iterator_traits` specialization might have
|
| 301 |
+
`iterator_concept` denote `input_iterator_tag` but not define
|
| 302 |
+
`iterator_category`. — *end example*]
|
| 303 |
+
|
| 304 |
`iterator_traits` is specialized for pointers as
|
| 305 |
|
| 306 |
``` cpp
|
| 307 |
namespace std {
|
| 308 |
template<class T>
|
|
|
|
| 316 |
using reference = T&;
|
| 317 |
};
|
| 318 |
}
|
| 319 |
```
|
| 320 |
|
| 321 |
+
[*Example 2*:
|
| 322 |
|
| 323 |
To implement a generic `reverse` function, a C++ program can do the
|
| 324 |
following:
|
| 325 |
|
| 326 |
``` cpp
|