std:: iter_value_t, std:: iter_reference_t, std:: iter_const_reference_t, std:: iter_difference_t, std:: iter_rvalue_reference_t, std:: iter_common_reference_t
|
Defined in header
<iterator>
|
||
|
template
<
class
T
>
using iter_value_t = /* see below */ ; |
(1) | (since C++20) |
|
template
<
/*dereferenceable*/
T
>
using iter_reference_t = decltype ( * std:: declval < T & > ( ) ) ; |
(2) | (since C++20) |
|
template
<
std::
indirectly_readable
T
>
using
iter_const_reference_t
=
|
(3) | (since C++23) |
|
template
<
class
T
>
using iter_difference_t = /* see below */ ; |
(4) | (since C++20) |
|
template
<
/*dereferenceable*/
T
>
requires
/* see below */
|
(5) | (since C++20) |
|
template
<
std::
indirectly_readable
T
>
using
iter_common_reference_t
=
|
(6) | (since C++20) |
|
Helper templates
|
||
|
template
<
class
T
>
concept /*dereferenceable*/ = /* see below */ ; |
(7) | ( exposition only* ) |
|
template
<
std::
indirectly_readable
T
>
using /*indirect-value-t*/ = /* see below */ ; |
(8) | ( exposition only* ) |
Compute the associated types of an iterator.
T
.
- If std:: iterator_traits < std:: remove_cvref_t < T >> is not specialized, then std :: iter_value_t < T > is std:: indirectly_readable_traits < std:: remove_cvref_t < T >> :: value_type .
- Otherwise, it is std:: iterator_traits < std:: remove_cvref_t < T >> :: value_type .
T
.
T
.
T
.
- If std:: iterator_traits < std:: remove_cvref_t < T >> is not specialized, then std :: iter_difference_t < T > is std:: incrementable_traits < std:: remove_cvref_t < T >> :: difference_type .
- Otherwise, it is std:: iterator_traits < std:: remove_cvref_t < T >> :: difference_type .
T
. The constraint on this alias template is satisfied if and only if the expression
ranges::
iter_move
(
std::
declval
<
T
&
>
(
)
)
is valid and has a referenceable type.
T
. This is the common reference type between its reference type and an lvalue reference to its value type.
dereferenceable
is satisfied if and only if the expression
*
std::
declval
<
T
&
>
(
)
is valid and has a
referenceable type
.
indirect-value-t
denotes the following:
-
std::
invoke_result_t
<
Proj
&
,
/*indirect-value-t*/
<
I
>>
if
Tis the same as std :: projected < I, Proj > for some typesIandProj. - Otherwise, std :: iter_value_t < T > & .
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| P2609R3 | C++20 |
std::iter_common_reference_t
was defined in terms
of std :: iter_value_t < T > & which incorrectly handled std::projected types that project into rvalue reference types |
defined in terms of
/*indirect-value-t*/ < T > to handle such cases |
See also
|
(C++20)
|
specifies that a type is indirectly readable by applying operator
*
(concept) |
|
(C++20)
|
specifies that a
semiregular
type can be incremented with pre- and post-increment operators
(concept) |
|
(C++20)
|
computes the value type of an
indirectly_readable
type
(class template) |
|
(C++20)
|
computes the difference type of a
weakly_incrementable
type
(class template) |
|
provides uniform interface to the properties of an iterator
(class template) |
|
|
(C++20)
(C++23)
(C++20)
(C++23)
|
obtains iterator and sentinel types of a range
(alias template) |
|
(C++20)
(C++23)
(C++20)
(C++20)
|
obtains reference types of a range
(alias template) |
|
(C++20)
(C++20)
(C++20)
|
obtains size, difference, and value types of a range
(alias template) |