std::iter_value_t, std::iter_reference_t, std::iter_const_reference_t, std::iter_difference_t, std::iter_rvalue_reference_t, std::
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&
>
(
)
)
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 termsof std::iter_value_t<T>& which incorrectly handled std::projected |
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) |