C++ named requirements: CharTraits

CharTraits ist eine Traits-Klasse, die grundlegende Zeichen- und Zeichenkettenoperationen für einen gegebenen Zeichentyp abstrahiert. Die meisten Standardbibliotheks-String- und Eingabe/Ausgabe-Klassen erfordern einen CharTraits Template-Typparameter zusammen mit einem entsprechenden Zeichen-Template-Typparameter.

Inhaltsverzeichnis 1 Anforderungen 2 Typen 3 Ausdrücke 4 Standardbibliothek 4.1 Strings 4.2 Streams 4.3 Stream-Iteratoren 4.4 Stream-Puffer 4.5 Stream-Puffer-Iteratoren 5 Fehlerberichte

Anforderungen

Keine der unten aufgeführten Operationen auf CharTraits darf eine Exception auslösen.

Gegeben

• CharT , ein Zeichentyp
• X , ein CharTraits -Typ für den Typ CharT
• c , d , Werte vom Typ CharT
• p , q , Werte vom Typ const CharT *
• s , ein Wert vom Typ CharT*
• n , i , j , Werte vom Typ std::size_t
• e , f , Werte vom Typ X::int_type
• pos , ein Wert vom Typ X::pos_type
• state , ein Wert vom Typ X::state_type
• r , ein Lvalue vom Typ CharT

Typen

Typ	Semantik
X::char_type	CharT
X::int_type	Ein Typ, der alle gültigen Werte von X::char_type sowie X :: eof ( ) halten kann
X::off_type	Ruft implementierungsdefiniertes Verhalten auf, falls nicht std::streamoff , wenn X als Traits-Template-Parameter in Eingabe-/Ausgabeklassen verwendet wird.
X::pos_type	Funktionen in Eingabe-/Ausgabeklassen, die diesen Typ zurückgeben, verwenden X :: pos_type ( X :: off_type ( - 1 ) ) als ungültigen Wert zur Fehlersignalisierung Die Verwendung dieses ungültigen Werts als Argument für jegliche std::istream -, std::ostream - oder std::streambuf -Memberfunktion, die einen Wert dieses Typs akzeptiert, ist undefiniertes Verhalten Ruft implementierungsdefiniertes Verhalten auf, falls dieser Typ nicht std::streampos ist, wenn X als Traits-Template-Parameter in Eingabe-/Ausgabeklassen verwendet wird
X::state_type	Destructible , CopyAssignable , CopyConstructible , DefaultConstructible

Ausdrücke

Ausdruck	Rückgabetyp	Semantik	Komplexität
X :: eq ( c, d )	bool	Gibt zurück: ob c als gleichwertig zu d zu behandeln ist	Konstante
X :: lt ( c, d )	bool	Gibt zurück: ob c als kleiner als d zu behandeln ist	Konstante
X :: compare ( p, q, n )	int	Gibt zurück: ​ 0 ​ falls für jedes i in [ ​ 0 ​ , n ) , X :: eq ( p [ i ] , q [ i ] ) true ist Andernfalls einen negativen Wert, falls Für ein j in [ ​ 0 ​ , n ) , X :: lt ( p [ j ] , q [ j ] ) true ist und Für jedes i in [ ​ 0 ​ , j ) , X :: eq ( p [ i ] , q [ i ] ) true ist Andernfalls einen positiven Wert	Linear
X :: length ( p )	std::size_t	Gibt zurück: das kleinste i für das X :: eq ( p [ i ] , CharT ( ) ) gleich true ist	Linear
X :: find ( p, n, c )	const X :: char_type *	Rückgabewert: Das kleinste q in [ p , p + n ) für das X :: eq ( * q, c ) den Wert true ergibt ​ 0 ​ andernfalls	Linear
X :: move ( s, p, n )	X::char_type*	Für jedes i in [ ​ 0 ​ , n ) führt aus: X :: assign ( s [ i ] , p [ i ] ) Kopiert korrekt selbst wenn sich die Bereiche [ p , p + n ) und [ s , s + n ) überlappen Rückgabewert: s	Linear
X :: copy ( s, p, n )	X::char_type*	Voraussetzung: [ p , p + n ) und [ s , s + n ) überlappen sich nicht Rückgabewert: s Für jedes i in [ ​ 0 ​ , n ) , führt aus X :: assign ( s [ i ] , p [ i ] )	Linear
X :: assign ( r, d )	(Nicht verwendet)	Weist zu r = d	Konstante
X :: assign ( s, n, c )	X::char_type*	Für jedes i in [ ​ 0 ​ , n ) , führt aus X :: assign ( s [ i ] , c ) . Gibt zurück: s	Linear
X :: not_eof ( e )	X::int_type	Gibt zurück: e falls X :: eq_int_type ( e, X :: eof ( ) ) false ist Andernfalls einen Wert f für den X :: eq_int_type ( f, X :: eof ( ) ) false ist	Konstante
X :: to_char_type ( e )	X::char_type	Gibt zurück: Falls für ein c , X :: eq_int_type ( e, X :: to_int_type ( c ) ) gleich true ist, c Andernfalls einen nicht spezifizierten Wert	Konstante
X :: to_int_type ( c )	X::int_type	Gibt zurück: einen Wert e , beschränkt durch die Definitionen von X::to_char_type und X::eq_int_type	Konstante
X :: eq_int_type ( e, f )	bool	Für alle c und d ist X :: eq ( c, d ) gleich X :: eq_int_type ( X :: to_int_type ( c ) , X :: to_int_type ( d ) ) Rückgabewert: Liefert X :: eq ( c, d ) falls für bestimmte c und d gilt: e == X :: to_int_type ( c ) und f == X :: to_int_type ( d ) Andernfalls liefert true falls e und f beide Kopien von X :: eof ( ) sind Andernfalls liefert false falls einer von e und f eine Kopie von X :: eof ( ) ist und der andere nicht Andernfalls ist der Wert nicht spezifiziert	Konstante
X :: eof ( )	X::int_type	Gibt zurück: einen Wert e für den X :: eq_int_type ( e, X :: to_int_type ( c ) ) für alle Werte c false ist	Konstante

Standardbibliothek

CharTraits wird von den folgenden Standardbibliothek-Klassenvorlagen als Template-Typparameter benötigt:

Strings
basic_string	speichert und manipuliert Zeichenfolgen (Klassentemplate)
basic_string_view (C++17)	Schreibgeschützte String-Ansicht (Klassentemplate)
Streams
basic_ios	verwaltet einen beliebigen Streampuffer (Klassentemplate)
basic_istream	umschließt ein gegebenes abstraktes Gerät ( std::basic_streambuf ) und bietet eine hochwertige Eingabeschnittstelle (Klassentemplate)
basic_ifstream	implementiert High-Level-Dateistrom-Eingabeoperationen (Klassentemplate)
basic_istringstream	implementiert High-Level String-Stream-Eingabeoperationen (Klassentemplate)
basic_ispanstream (C++23)	implementiert Eingabeoperationen für feste Zeichenpuffer (Klassentemplate)
basic_ostream	umschließt ein gegebenes abstraktes Gerät ( std::basic_streambuf ) und bietet eine hochwertige Ausgabeschnittstelle (Klassentemplate)
basic_ofstream	implementiert High-Level-Dateistrom-Ausgabeoperationen (Klassentemplate)
basic_ostringstream	implementiert High-Level String-Stream-Ausgabeoperationen (Klassentemplate)
basic_osyncstream (C++20)	Synchronisierte Ausgabestrom-Hülle (Klassentemplate)
basic_ospanstream (C++23)	implementiert Ausgabeoperationen für feste Zeichenpuffer (Klassentemplate)
basic_iostream	umschließt ein gegebenes abstraktes Gerät ( std::basic_streambuf ) und bietet eine hochwertige Eingabe/Ausgabe-Schnittstelle (Klassentemplate)
basic_fstream	implementiert hochwertige Dateistrom-Ein-/Ausgabeoperationen (Klassentemplate)
basic_stringstream	implementiert High-Level String-Stream-Ein-/Ausgabeoperationen (Klassentemplate)
basic_spanstream (C++23)	implementiert Eingabe-/Ausgabeoperationen für feste Zeichenpuffer (Klassentemplate)
Stream-Iteratoren
istream_iterator	Eingabe-Iterator, der aus std::basic_istream liest (Klassen-Template)
ostream_iterator	Ausgabeiterator, der in std::basic_ostream schreibt (Klassentemplate)
Streampuffer
basic_streambuf	abstrahiert ein Rohgerät (Klassentemplate)
basic_filebuf	implementiert Rohdatei-Gerät (Klassentemplate)
basic_stringbuf	implementiert Roh-String-Gerät (Klassentemplate)
basic_syncbuf (C++20)	Synchronisierte Ausgabegeräte-Wrapper (Klassentemplate)
basic_spanbuf (C++23)	implementiert ein Roh-Fixed-Character-Puffer-Device (Klassentemplate)
Stream-Puffer-Iteratoren
istreambuf_iterator	Eingabe-Iterator, der von std::basic_streambuf liest (Klassentemplate)
ostreambuf_iterator	Ausgabeiterator, der in std::basic_streambuf schreibt (Klassentemplate)

CharTraits wird durch die folgenden Standardbibliothek-Explizitspezialisierungen von std::char_traits erfüllt:

template <> class char_traits < char > ; template <> class char_traits < wchar_t > ; template <> class char_traits < char8_t > ; template <> class char_traits < char16_t > ; template <> class char_traits < char32_t > ;		(seit C++20) (seit C++11) (seit C++11)

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 335	C++98	die Anforderungen an die binäre Überladung von assign verhinderten keine Zuweisungen an Rvalues	ihr erstes Argument kann nur ein Lvalue sein
LWG 352	C++98	X::state_type war nur erforderlich CopyConstructible zu sein	es ist auch erforderlich CopyAssignable und DefaultConstructible zu sein
LWG 3085	C++98	X :: copy ( s, p, n ) erforderte nur p nicht in [ s , s + n ) zu sein, was zu schwach ist [1]	erfordert, dass [ p , p + n ) und [ s , s + n ) sich nicht überlappen

1. ↑ [ p , p + n ) und [ s , s + n ) können sich überlappen. Die Verwendung von std::memcpy zur Implementierung von X::copy führt in diesem Fall zu undefiniertem Verhalten.