◐ Shell
clean mode source ↗

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

From cppreference.com

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 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 const reference type of T.

4) 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.

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 dereferenceable is satisfied if and only if the expression *std::declval<T&>() is valid and its type is not (possibly cv-qualified) void.

8) The exposition-only alias template indirect-value-t denotes the following:

  • std::invoke_result_t<Proj&, /*indirect-value-t*/<I>> if T is the same as std::projected<I, Proj> for some types I and Proj.
  • 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

specifies that a type is indirectly readable by applying operator *
(concept) [edit]
specifies that a semiregular type can be incremented with pre- and post-increment operators
(concept) [edit]
computes the value type of an indirectly_readable type
(class template) [edit]
computes the difference type of a weakly_incrementable type
(class template) [edit]
provides uniform interface to the properties of an iterator
(class template) [edit]
obtains iterator and sentinel types of a range
(alias template)[edit]
obtains reference types of a range
(alias template)[edit]
obtains size, difference, and value types of a range
(alias template)[edit]