std::iter_value_t, std::iter_reference_t, std::iter_difference_t, std::iter_rvalue_reference_t, std::iter_common_reference_t
Defined in header <iterator> |
||
|---|---|---|
template< class T > concept /*dereferenceable*/ = /* see below */; // exposition only |
||
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< class T > using iter_difference_t = /* see below */; |
(3) | (since C++20) |
template< /*dereferenceable*/ T>
requires /* see below */
using iter_rvalue_reference_t = decltype(ranges::iter_move(std::declval<T&>())); |
(4) | (since C++20) |
template< std::indirectly_readable T >
using iter_common_reference_t = std::common_reference_t<std::iter_reference_t<T>,
std::iter_value_t<T>&>; |
(5) | (since C++20) |
Compute the associated types of an iterator. The exposition-only concept dereferenceable is satisfied if and only if the expression *std::declval<T&>() is valid and has a referenceable type (in particular, not void).
1) Computes the
value type of
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.
2) Computes the
reference type of
T.
3) Computes the
difference type of
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.
4) Computes the
rvalue reference type of
T. The "see below" portion of 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 (in particular, not
void).
5) 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.
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) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/iterator/iter_t
