std:: indirectly_readable_traits

Défini dans l'en-tête <iterator>
template < class I > struct indirectly_readable_traits { } ;	(1)	(depuis C++20)
template < class T > struct indirectly_readable_traits < T * > : /* type-valeur-condition */ < T > { } ;	(2)	(depuis C++20)
template < class I > requires std:: is_array_v < I > struct indirectly_readable_traits < I > ; { using value_type = std:: remove_cv_t < std:: remove_extent_t < I >> ; }	(3)	(depuis C++20)
template < class T > struct indirectly_readable_traits < const T > : indirectly_readable_traits < T > { } ;	(4)	(depuis C++20)
template < /* has-member-value-type */ T > struct indirectly_readable_traits < T > : /* cond-value-type */ < typename T :: value_type > { } ;	(5)	(depuis C++20)
template < /* has-member-element-type */ T > struct indirectly_readable_traits < T > : /* cond-value-type */ < typename T :: element_type > { } ;	(6)	(depuis C++20)
template < /* has-member-value-type */ T > requires /* has-member-element-type */ < T > struct indirectly_readable_traits < T > { } ;	(7)	(depuis C++20)
template < /* has-member-value-type */ T > requires /* has-member-element-type */ < T > && std:: same_as < std:: remove_cv_t < typename T :: element_type > , std:: remove_cv_t < typename T :: value_type >> struct indirectly_readable_traits < T > : /* cond-value-type */ < typename T :: value_type > { } ;	(8)	(depuis C++20)
Classes et concepts auxiliaires
template < class > struct /* type-valeur-condition */ { } ;	(1)	( exposition uniquement* )
template < class T > requires std:: is_object_v < T > struct /* type-valeur-condition */ < T > { using value_type = std:: remove_cv_t < T > ; } ;	(2)	( exposition uniquement* )
template < class T > concept /* a-un-type-de-membre-valeur */ = requires { typename T :: value_type ; } ;	(3)	( exposition uniquement* )
template < class T > concept /* a-un-type-element-membre */ = requires { typename T :: element_type ; } ;	(4)	( exposition uniquement* )

Calcule le type de valeur associé de l'argument template. Si le type de valeur associé existe, il est représenté par le type imbriqué value_type , sinon value_type n'est pas défini. Un programme peut spécialiser indirectly_readable_traits pour un type défini par le programme .

Table des matières 1 Explication 2 Notes 3 Exemple 4 Rapports de défauts 5 Voir aussi

Explication

Les spécialisations ci-dessus peuvent être décrites de manière informelle comme suit.

Étant donné un type T , son type de valeur associé V est déterminé comme suit :

• Si T est qualifié const, V est le type de valeur associé de T non qualifié const.
• Sinon, si T est un type tableau, V est le type d'élément du tableau non qualifié cv.
• Sinon, un type de valeur conditionnel C est d'abord déterminé :

• Si T est un type pointeur, C est le type pointé.
• Sinon, si T a les types imbriqués value_type et element_type :

• Si ces types sont identiques (sans considération des qualificateurs cv), C est typename T::value_type .
• Sinon, C est indéfini.

• Sinon, si T a le type imbriqué value_type mais pas element_type , C est typename T::value_type .
• Sinon, si T a le type imbriqué element_type mais pas value_type , C est typename T::element_type .
• Sinon, C est indéfini.

Ensuite V est déterminé à partir de C comme suit :

• Si C est indéfini, ou C n'est pas un type objet , V est indéfini.
• Sinon, V est C sans qualificateurs cv.

Notes

value_type est destiné à être utilisé avec des types indirectly_readable tels que les itérateurs. Il n'est pas destiné à être utilisé avec des plages.

Exemple

Cette section est incomplète Raison : aucun exemple

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é
LWG 3446	C++20	les spécialisations (5,6) étaient ambiguës pour les types ayant à la fois value_type et element_type comme types imbriqués	spécialisation ajoutée (8)
LWG 3541	C++20	LWG 3446 introduisait une erreur irrécupérable pour les cas ambigus où value_type et element_type sont différents	spécialisation ajoutée (7)

Voir aussi

indirectly_readable (C++20)	spécifie qu'un type est indirectement lisible en appliquant l'opérateur * (concept)
iter_value_t iter_reference_t iter_const_reference_t iter_difference_t iter_rvalue_reference_t iter_common_reference_t (C++20) (C++20) (C++23) (C++20) (C++20) (C++20)	calcule les types associés d'un itérateur (alias template)
iterator_traits	fournit une interface uniforme pour les propriétés d'un itérateur (class template)