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 =
std::common_reference_t<const std::iter_value_t<T>&&,
std::iter_reference_t<T>>;
| (3) | (since C++23) |
template< class T > using iter_difference_t = /* see below */; | (4) | (since C++20) |
template< /*dereferenceable*/ T>
requires /* see below */
using iter_rvalue_reference_t =
decltype(ranges::iter_move(std::declval<T&>()));
| (5) | (since C++20) |
template< std::indirectly_readable T >
using iter_common_reference_t =
std::common_reference_t<std::iter_reference_t<T>,
/*indirect-value-t*/<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.
1) Computes the value type ofT. - 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.
2) Computes the reference type of
T.
3) Computes the const reference type of
4) Computes the difference type of 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.
5) Computes the rvalue reference type of
T. The constraint on this alias template is satisfied if and only if the expression ranges::iter_move(std::declval<T&>()) is valid and its type is not (possibly cv-qualified) void.
6) Computes the common reference type of
T. This is the common reference type between its reference type and an lvalue reference to its value type.
7) The exposition-only concept
8) The exposition-only alias template dereferenceable is satisfied if and only if the expression *std::declval<T&>() is valid and its type is not (possibly cv-qualified) void.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 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) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/iterator/iter_t
