# std::iter_value_t, std::iter_reference_t, std::iter_difference_t, std::iter_rvalue_reference_t, std::iter_common_reference_t

From cppreference.com
< cpp‎ | iterator

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< 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 <T> is not specialized, then std::iter_value_t<T> is std::readable_traits<T>::value_type. Otherwise, it is std::iterator_traits <T>::value_type.
2) Computes the reference type of `T`.
3) Computes the difference type of `T`. If std::iterator_traits <T> is not specialized, then std::iter_difference_t<T> is std::incrementable_traits<T>::difference_type. Otherwise, it is std::iterator_traits <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

Readable | specifies that a type is readable by applying operator `*` (concept)
WeaklyIncrementable | specifies that a `Semiregular` type can be incremented with pre- and post-increment operators (concept)
readable_traits | computes the value type of a `Readable` type (class template)
incrementable_traits | computes the difference type of a `WeaklyIncrementable` type (class template)
iterator_traits | provides uniform interface to the properties of an iterator (class template)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/iterator/iter_t&oldid=108340"