std:: indirectly_readable_traits

(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute gemäß den Anweisungen unverändert bleiben sollen und die Tabellenzellen leer sind.)

Definiert im Header <iterator>
template < class I > struct indirectly_readable_traits { } ;	(1)	(seit C++20)
template < class T > struct indirectly_readable_traits < T * > : /* Werttyp-Bedingung */ < T > { } ;	(2)	(seit 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)	(seit C++20)
template < class T > struct indirectly_readable_traits < const T > : indirectly_readable_traits < T > { } ;	(4)	(seit C++20)
template < /* has-member-value-type */ T > struct indirectly_readable_traits < T > : /* cond-value-type */ < typename T :: value_type > { } ;	(5)	(seit C++20)
template < /* has-member-element-type */ T > struct indirectly_readable_traits < T > : /* cond-value-type */ < typename T :: element_type > { } ;	(6)	(seit C++20)
template < /* has-member-value-type */ T > requires /* has-member-element-type */ < T > struct indirectly_readable_traits < T > { } ;	(7)	(seit 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)	(seit C++20)
Hilfsklassen und Konzepte
template < class > struct /* Bedingungs-Wert-Typ */ { } ;	(1)	( Nur zur Darstellung* )
template < class T > requires std:: is_object_v < T > struct /* cond-value-type */ < T > { using value_type = std:: remove_cv_t < T > ; } ;	(2)	( Nur zur Darstellung* )
template < class T > concept /* hat-Mitglied-Werttyp */ = requires { typename T :: value_type ; } ;	(3)	( nur zur Darstellung* )
template < class T > concept /* hat-Mitglied-Element-Typ */ = requires { typename T :: element_type ; } ;	(4)	( Nur zur Darstellung* )

Berechnet den assoziierten Werttyp des Template-Arguments. Falls der assoziierte Werttyp existiert, wird er durch den geschachtelten Typ value_type repräsentiert, andernfalls ist value_type nicht definiert. Ein Programm kann indirectly_readable_traits für einen programmdefinierten Typ spezialisieren.

Inhaltsverzeichnis 1 Erklärung 2 Hinweise 3 Beispiel 4 Fehlerberichte 5 Siehe auch

Erklärung

Die oben genannten Spezialisierungen können informell wie folgt beschrieben werden.

Gegeben einen Typ T , wird sein assoziierter Werttyp V wie folgt bestimmt:

• Wenn T const-qualifiziert ist, V der zugehörige Werttyp des const-unqualifizierten T ist.
• Andernfalls, wenn T ein Array-Typ ist, V der cv-unqualifizierte Array-Elementtyp ist.
• Andernfalls wird zunächst ein bedingter Werttyp C bestimmt:

• Falls T ein Zeigertyp ist, C ist der gezeigte Typ.
• Andernfalls, falls T die geschachtelten Typen value_type und element_type besitzt:

• Falls diese Typen identisch sind (ohne Berücksichtigung von CV-Qualifizierern), C ist typename T::value_type .
• Andernfalls ist C undefiniert.

• Andernfalls, falls T den geschachtelten Typ value_type aber nicht element_type besitzt, C ist typename T::value_type .
• Andernfalls, falls T den geschachtelten Typ element_type aber nicht value_type besitzt, C ist typename T::element_type .
• Andernfalls ist C undefiniert.

Dann wird V aus C wie folgt bestimmt:

• Falls C undefiniert ist, oder C kein Objekttyp ist, V ist undefiniert.
• Andernfalls ist V CV-unqualifiziertes C .

Hinweise

value_type ist für die Verwendung mit indirectly_readable -Typen wie Iteratoren vorgesehen. Es ist nicht für die Verwendung mit Ranges gedacht.

Beispiel

Dieser Abschnitt ist unvollständig Grund: Kein Beispiel

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	Angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 3446	C++20	Spezialisierungen (5,6) waren mehrdeutig für Typen mit sowohl value_type als auch element_type verschachtelten Typen	Spezialisierung (8) hinzugefügt
LWG 3541	C++20	LWG 3446 führte schwerwiegenden Fehler für mehrdeutige Fälle ein bei denen value_type und element_type unterschiedlich sind	Spezialisierung (7) hinzugefügt

Siehe auch

indirectly_readable (C++20)	spezifiziert, dass ein Typ indirekt lesbar durch Anwendung des Operators * ist (Konzept)
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)	berechnet die assoziierten Typen eines Iterators (Alias-Template)
iterator_traits	bietet eine einheitliche Schnittstelle zu den Eigenschaften eines Iterators (Klassen-Template)