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

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Iterator library

Iterator concepts
indirectly_readable (C++20) indirectly_writable (C++20) weakly_incrementable (C++20) incrementable (C++20) input_or_output_iterator (C++20) sentinel_for (C++20) sized_sentinel_for (C++20)	input_iterator (C++20) output_iterator (C++20) forward_iterator (C++20) bidirectional_iterator (C++20) random_access_iterator (C++20) contiguous_iterator (C++20)
Iterator primitives
iterator_traits input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20) iterator (deprecated in C++17)	incrementable_traits (C++20) indirectly_readable_traits (C++20) iter_value_titer_difference_titer_reference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++20)(C++20)(C++20)
Algorithm concepts and utilities
Indirect callable concepts
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20) indirect_unary_predicate (C++20)	indirect_binary_predicate (C++20) indirect_equivalence_relation (C++20) indirect_strict_weak_order (C++20)
Common algorithm requirements
indirectly_movable (C++20) indirectly_movable_storable (C++20) indirectly_copyable (C++20) indirectly_copyable_storable (C++20)	indirectly_swappable (C++20) indirectly_comparable (C++20) permutable (C++20) mergeable (C++20) sortable (C++20)
Utilities
indirect_result_t	projected
Iterator adaptors
reverse_iterator move_iterator (C++11) move_sentinel (C++20) common_iterator (C++20) counted_iterator (C++20) back_insert_iterator front_insert_iterator insert_iterator	make_reverse_iterator (C++14) make_move_iterator (C++11) default_sentinel_tdefault_sentinel (C++20)(C++20) unreachable_sentinel_tunreachable_sentinel (C++20)(C++20) back_inserter front_inserter inserter
Stream iterators
istream_iterator ostream_iterator	istreambuf_iterator ostreambuf_iterator
Iterator customization points
ranges::iter_move (C++20)
ranges::iter_swap (C++20)
Iterator operations
advance distance prev (C++11) next (C++11)	ranges::advance (C++20) ranges::distance (C++20) ranges::prev (C++20) ranges::next (C++20)
Range access
begincbegin (C++11)(C++14) endcend (C++11)(C++14) sizessize (C++17)(C++20)	rbegincrbegin (C++14)(C++14) rendcrend (C++14)(C++14) empty (C++17) data (C++17)

 

Defined in header <iterator>
template< class T > concept __Referenceable = /* see below */; // exposition only
template< class T > using iter_value_t = /* see below */;	(1)	(since C++20)
template< __Referenceable 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< __Referenceable 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 __Referenceable 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

indirectly_readable (C++20)	specifies that a type is indirectly readable by applying operator * (concept)
weakly_incrementable (C++20)	specifies that a semiregular type can be incremented with pre- and post-increment operators (concept)
indirectly_readable_traits (C++20)	computes the value type of an indirectly_readable type (class template)
incrementable_traits (C++20)	computes the difference type of a weakly_incrementable type (class template)
iterator_traits	provides uniform interface to the properties of an iterator (class template)