std:: indirectly_readable_traits

Definido en el encabezado <iterator>
template < class I > struct indirectly_readable_traits { } ;	(1)	(desde C++20)
template < class T > struct indirectly_readable_traits < T * > : /* tipo-valor-condicional */ < T > { } ;	(2)	(desde C++20)
template < class I > requiere std:: is_array_v < I > struct indirectly_readable_traits < I > ; { using value_type = std:: remove_cv_t < std:: remove_extent_t < I >> ; }	(3)	(desde C++20)
template < class T > struct indirectly_readable_traits < const T > : indirectly_readable_traits < T > { } ;	(4)	(desde C++20)
template < /* has-member-value-type */ T > struct indirectly_readable_traits < T > : /* cond-value-type */ < typename T :: value_type > { } ;	(5)	(desde C++20)
template < /* has-member-element-type */ T > struct indirectly_readable_traits < T > : /* cond-value-type */ < typename T :: element_type > { } ;	(6)	(desde C++20)
template < /* has-member-value-type */ T > requires /* has-member-element-type */ < T > struct indirectly_readable_traits < T > { } ;	(7)	(desde 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)	(desde C++20)
Clases auxiliares y conceptos
template < class > struct /* cond-value-type */ { } ;	(1)	( solo para exposición* )
template < class T > requires std:: is_object_v < T > struct /* tipo-valor-cond */ < T > { using value_type = std:: remove_cv_t < T > ; } ;	(2)	( solo para exposición* )
template < class T > concept /* tiene-tipo-valor-miembro */ = requires { typename T :: value_type ; } ;	(3)	( solo para exposición* )
template < class T > concepto /* has-member-element-type */ = requiere { typename T :: element_type ; } ;	(4)	( solo para exposición* )

Calcula el tipo de valor asociado del argumento de plantilla. Si el tipo de valor asociado existe, se representa mediante el tipo anidado value_type , de lo contrario value_type no está definido. Un programa puede especializar indirectly_readable_traits para un tipo definido por el programa .

Contenidos 1 Explicación 2 Notas 3 Ejemplo 4 Reportes de defectos 5 Véase también

Explicación

Las especializaciones anteriores pueden describirse informalmente de la siguiente manera.

Dado un tipo T , su tipo de valor asociado V se determina de la siguiente manera:

• Si T está calificado con const, V es el tipo de valor asociado de T sin calificación const.
• De lo contrario, si T es un tipo array, V es el tipo de elemento del array sin calificación cv.
• De lo contrario, primero se determina un tipo de valor condicional C :

• Si T es un tipo puntero, C es el tipo apuntado.
• En caso contrario, si T tiene tipos anidados value_type y element_type :

• Si estos tipos son iguales (sin considerar calificadores cv), C es typename T::value_type .
• En caso contrario, C no está definido.

• En caso contrario, si T tiene el tipo anidado value_type pero no element_type , C es typename T::value_type .
• En caso contrario, si T tiene el tipo anidado element_type pero no value_type , C es typename T::element_type .
• En caso contrario, C no está definido.

Entonces V se determina a partir de C como sigue:

• Si C no está definido, o C no es un tipo objeto , V no está definido.
• En caso contrario, V es C sin calificadores cv.

Notas

value_type está destinado para su uso con tipos indirectly_readable como los iteradores. No está destinado para su uso con rangos.

Ejemplo

Esta sección está incompleta Motivo: sin ejemplo

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR	Aplicado a	Comportamiento publicado	Comportamiento correcto
LWG 3446	C++20	las especializaciones (5,6) eran ambiguas para tipos que tienen tanto value_type como element_type como tipos anidados	se añadió la especialización (8)
LWG 3541	C++20	LWG 3446 introdujo un error grave para casos ambiguos donde value_type y element_type son diferentes	se añadió la especialización (7)

Véase también

indirectly_readable (C++20)	especifica que un tipo es indirectamente legible aplicando el operador * (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)	calcula los tipos asociados de un iterador (alias template)
iterator_traits	proporciona una interfaz uniforme para las propiedades de un iterador (class template)