Namespaces
Variants

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.net
C++
Iterator library
Iterator concepts
Iterator primitives
iter_value_t iter_difference_t iter_reference_t iter_const_reference_t iter_rvalue_reference_t iter_common_reference_t
(C++20) (C++20) (C++20) (C++23) (C++20) (C++20)
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
Défini dans l'en-tête <iterator>
template < class T >
using iter_value_t = /* voir ci-dessous */ ;
(1) (depuis C++20)
template < /*déréférençable*/ T >
using iter_reference_t = decltype ( * std:: declval < T & > ( ) ) ;
(2) (depuis 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) (depuis C++23)
template < class T >
using iter_difference_t = /* voir ci-dessous */ ;
(4) (depuis C++20)
template < /*dereferenceable*/ T >

requires /* voir ci-dessous */
using iter_rvalue_reference_t =

decltype ( ranges:: iter_move ( std:: declval < T & > ( ) ) ) ;
(5) (depuis C++20)
template < std:: indirectly_readable T >

using iter_common_reference_t =
std:: common_reference_t < std :: iter_reference_t < T > ,

/*type-valeur-indirect*/ < T >> ;
(6) (depuis C++20)
Modèles d'assistance
template < class T >
concept /*dereferenceable*/ = /* voir ci-dessous */ ;
(7) ( exposition uniquement* )
template < std:: indirectly_readable T >
using /*indirect-value-t*/ = /* voir ci-dessous */ ;
(8) ( exposition uniquement* )

Calcule les types associés d'un itérateur.

1) Calcule le type de valeur de T .
2) Calcule le type référence de T .
3) Calcule le const reference type de T .
4) Calcule le type de différence de T .
5) Calcule le type de référence rvalue de T . La contrainte sur cet alias template est satisfaite si et seulement si l'expression ranges:: iter_move ( std:: declval < T & > ( ) ) est valide et a un type référençable.
6) Calcule le type de référence commun de T . Ceci est le type de référence commun entre son type de référence et une référence lvalue à son type de valeur.
7) Le concept d'exposition uniquement dereferenceable est satisfait si et seulement si l'expression * std:: declval < T & > ( ) est valide et possède un type référençable .
8) Le modèle d'alias d'exposition uniquement indirect-value-t dénote ce qui suit :
  • std:: invoke_result_t < Proj & , /*indirect-value-t*/ < I >> si T est identique à std :: projected < I, Proj > pour certains types I et Proj .
  • Sinon, std :: iter_value_t < T > & .

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
P2609R3 C++20 std::iter_common_reference_t était défini en termes
de std :: iter_value_t < T > & ce qui gérait incorrectement
std::projected les types qui projettent vers des types de référence rvalue 		défini en termes de
/*indirect-value-t*/ < T >
pour gérer ces cas

Voir aussi

(C++20)
spécifie qu'un type est indirectement lisible en appliquant l'opérateur *
(concept)
(C++20)
spécifie qu'un type semiregular peut être incrémenté avec les opérateurs de pré-incrémentation et post-incrémentation
(concept)
(C++20)
calcule le type de valeur d'un type indirectly_readable
(modèle de classe)
(C++20)
calcule le type de différence d'un type weakly_incrementable
(modèle de classe)
fournit une interface uniforme aux propriétés d'un itérateur
(modèle de classe)
(C++20) (C++23) (C++20) (C++23)
obtient les types d'itérateur et de sentinelle d'une plage
(modèle d'alias)
(C++20) (C++23) (C++20) (C++20)
obtient les types de référence d'une plage
(modèle d'alias)
(C++20) (C++20) (C++20)
obtient les types de taille, de différence et de valeur d'une plage
(modèle d'alias)