C++ benannte Anforderungen: CharTraits

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

C++ benannte Anforderungen

Basis DefaultConstructible MoveConstructible (C++11) CopyConstructible CopyAssignable MoveAssignable (C++11) Destructible Typeneigenschaften ScalarType PODType TriviallyCopyable (C++11) TrivialType (C++11) StandardLayoutType (C++11)   ImplicitLifetimeType Bibliothekweit BooleanTestable EqualityComparable LessThanComparable Swappable ValueSwappable (C++11) NullablePointer (C++11) Hash (C++11) Allocator FunctionObject Callable Predicate BinaryPredicate Compare

Container Container ReversibleContainer AllocatorAwareContainer SequenceContainer ContiguousContainer (C++17) AssociativeContainer UnorderedAssociativeContainer (C++11)   Container-Element DefaultInsertable (C++11) CopyInsertable (C++11) MoveInsertable (C++11) EmplaceConstructible (C++11) Erasable (C++11) Iterator LegacyIterator LegacyInputIterator LegacyOutputIterator LegacyForwardIterator LegacyBidirectionalIterator LegacyRandomAccessIterator LegacyContiguousIterator (C++17) ConstexprIterator (C++20) Stream-I/O FormattedInputFunction UnformattedInputFunction FormattedOutputFunction UnformattedOutputFunction Formatters BasicFormatter (C++20) Formatter (C++20)

Zufallszahlen SeedSequence (C++11) RandomNumberEngine (C++11) RandomNumberDistribution (C++11) UniformRandomBitGenerator (C++11) RandomNumberEngineAdaptor (C++11) Concurrency BasicLockable (C++11) Lockable (C++11) TimedLockable (C++11) SharedLockable (C++14) SharedTimedLockable (C++14) Mutex (C++11) TimedMutex (C++11) SharedMutex (C++17) SharedTimedMutex (C++14) Bereiche (Ranges) RangeAdaptorObject (C++20) RangeAdaptorClosureObject (C++20) Mehrdimensionale Ansicht LayoutMapping (C++23) LayoutMappingPolicy (C++23) AccessorPolicy (C++23) Sonstiges CharTraits RegexTraits (C++11)   BitmaskType LiteralType (C++11) NumericType UnaryTypeTrait (C++11) BinaryTypeTrait (C++11) TransformationTrait (C++11) Clock (C++11) TrivialClock (C++11)

 

CharTraits ist eine Traits-Klasse, die grundlegende Zeichen- und String-Operationen für einen bestimmten Zeichentyp abstrahiert. Die meisten Standardbibliotheks-String- und Ein-/Ausgabeklassen erfordern neben einem entsprechenden Zeichentyp-Template-Parameter auch einen CharTraits-Template-Typ-Parameter.

Anforderungen

Keine der unten aufgeführten Operationen auf CharTraits darf eine Ausnahme 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 L-Wert vom Typ CharT

Typen

Typ	Semantik
X::char_type	CharT
X::int_type	Ein Typ, der alle gültigen Werte von X::char_type plus X::eof() aufnehmen kann
X::off_type	Ruft implementierungsdefiniertes Verhalten auf, wenn es sich nicht um std::streamoff handelt, wenn X als Traits-Template-Parameter in Ein-/Ausgabeklassen verwendet wird.
X::pos_type	Funktionen in Ein-/Ausgabeklassen, die diesen Typ zurückgeben, verwenden X::pos_type(X::off_type(-1)) als ungültigen Wert, um einen Fehler zu signalisieren Die Verwendung dieses ungültigen Wertes als Argument für ein beliebiges Mitglied von std::istream, std::ostream oder std::streambuf, das einen Wert dieses Typs entgegennimmt, ist undefiniertes Verhalten. Ruft implementierungsdefiniertes Verhalten auf, wenn dieser Typ nicht std::streampos ist, wenn X als Traits-Template-Parameter in Ein-/Ausgabeklassen verwendet wird.
X::state_type	Destructible, CopyAssignable, CopyConstructible, DefaultConstructible

Ausdrücke

Ausdruck	Rückgabetyp	Semantik	Komplexität
X::eq(c, d)	bool	Rückgabewert: Gibt an, ob c als gleich d behandelt werden soll.	Konstante
X::lt(c, d)	bool	Rückgabewert: Gibt an, ob c als kleiner als d behandelt werden soll.	Konstante
X::compare(p, q, n)	int	Gibt zurück ​0​, wenn für jedes i in [​0​, n) gilt: X::eq(p[i], q[i]) ist true. Andernfalls ein negativer Wert, wenn für ein j in [​0​, n) gilt: X::lt(p[j], q[j]) ist true und für jedes i in [​0​, j) gilt: X::eq(p[i], q[i]) ist true. Andernfalls ein positiver Wert.	Linear
X::length(p)	std::size_t	Rückgabewert: Gibt den kleinsten Wert i zurück, so dass X::eq(p[i], CharT()) true ist.	Linear
X::find(p, n, c)	const X::char_type*	Gibt zurück Der kleinste Wert q in [p, p + n), so dass X::eq(*q, c) true ist. ​0​ andernfalls.	Linear
X::move(s, p, n)	X::char_type*	Für jedes i in [​0​, n) wird X::assign(s[i], p[i]) ausgeführt. Kopiert korrekt, auch wenn sich die Bereiche [p, p + n) und [s, s + n) überschneiden. Rückgabewert: s	Linear
X::copy(s, p, n)	X::char_type*	Anforderung: Die Bereiche [p, p + n) und [s, s + n) dürfen sich nicht überschneiden. Rückgabewert: s Für jedes i in [​0​, n) wird X::assign(s[i], p[i]) ausgeführt.	Linear
X::assign(r, d)	(Nicht verwendet)	Weist r = d zu.	Konstante
X::assign(s, n, c)	X::char_type*	Für jedes i in [​0​, n) wird X::assign(s[i], c) ausgeführt. Rückgabewert: s	Linear
X::not_eof(e)	X::int_type	Gibt zurück e, wenn X::eq_int_type(e, X::eof()) false ist. Andernfalls ein Wert f, so dass X::eq_int_type(f, X::eof()) false ist.	Konstante
X::to_char_type(e)	X::char_type	Gibt zurück Wenn für ein c gilt: X::eq_int_type(e, X::to_int_type(c)) ist true, dann c. Andernfalls ein nicht spezifizierter Wert.	Konstante
X::to_int_type(c)	X::int_type	Rückgabewert: Gibt einen Wert e zurück, der durch die Definitionen von X::to_char_type und X::eq_int_type eingeschränkt ist.	Konstante
X::eq_int_type(e, f)	bool	Für alle c und d gilt: X::eq(c, d) ist gleich X::eq_int_type(X::to_int_type(c),                X::to_int_type(d)). Gibt zurück Gibt X::eq(c, d) zurück, wenn für ein c und d gilt: e == X::to_int_type(c) und f == X::to_int_type(d). Andernfalls gibt es true zurück, wenn e und f beide Kopien von X::eof() sind. Andernfalls gibt es false zurück, wenn einer der Werte 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	Rückgabewert: Gibt einen Wert e zurück, 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 Standardbibliotheks-Klassentemplates als Template-Typ-Parameter benötigt.

Strings
basic_string	speichert und manipuliert Zeichenfolgen (Klassenvorlage)
basic_string_view (C++17)	schreibgeschützte String-Ansicht (class template)
Streams
basic_ios	verwaltet einen beliebigen Stream-Puffer (Klassen-Template)
basic_istream	kapselt ein gegebenes abstraktes Gerät (std::basic_streambuf) und stellt eine High-Level-Eingabeschnittstelle bereit (class template)
basic_ifstream	implementiert High-Level-Datei-Stream-Eingabeoperationen (Klassen-Template)
basic_istringstream	implementiert High-Level-String-Stream-Eingabeoperationen (Klassen-Template)
basic_ispanstream (C++23)	implementiert Eingabeoperationen für Puffer mit festen Zeichen (Klassen-Template)
basic_ostream	kapselt ein gegebenes abstraktes Gerät (std::basic_streambuf) und stellt eine High-Level-Ausgabeschnittstelle bereit (class template)
basic_ofstream	implementiert High-Level-Datei-Stream-Ausgabeoperationen (Klassen-Template)
basic_ostringstream	implementiert High-Level-String-Stream-Ausgabeoperationen (Klassen-Template)
basic_osyncstream (C++20)	Wrapper für synchronisierte Ausgabe-Streams (Klassen-Template)
basic_ospanstream (C++23)	implementiert Ausgabeoperationen für Puffer mit festen Zeichen (Klassen-Template)
basic_iostream	kapselt ein gegebenes abstraktes Gerät (std::basic_streambuf) und stellt eine High-Level-Ein-/Ausgabe-Schnittstelle bereit (Klassen-Template)
basic_fstream	implementiert High-Level-Datei-Stream-Ein-/Ausgabeoperationen (Klassen-Template)
basic_stringstream	implementiert High-Level-String-Stream-Ein-/Ausgabeoperationen (Klassen-Template)
basic_spanstream (C++23)	implementiert Ein-/Ausgabeoperationen für Puffer mit festen Zeichen (Klassen-Template)
Stream-Iteratoren
istream_iterator	Eingabe-Iterator, der aus std::basic_istream liest (Klassenvorlage)
ostream_iterator	Ausgabe-Iterator, der in std::basic_ostream schreibt (Klassenvorlage)
Stream-Puffer
basic_streambuf	abstrahiert ein Rohgerät (class template)
basic_filebuf	implementiert rohe Datei-Geräte (Klassen-Template)
basic_stringbuf	implementiert rohe String-Geräte (Klassen-Template)
basic_syncbuf (C++20)	Wrapper für synchronisierte Ausgabegeräte (Klassen-Template)
basic_spanbuf (C++23)	implementiert rohe Puffergeräte mit festen Zeichen (Klassen-Template)
Stream-Puffer-Iteratoren
istreambuf_iterator	Eingabe-Iterator, der aus std::basic_streambuf liest (Klassenvorlage)
ostreambuf_iterator	Ausgabe-Iterator, der in std::basic_streambuf schreibt (Klassenvorlage)

CharTraits wird von den folgenden expliziten Spezialisierungen von std::char_traits in der Standardbibliothek 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 erlaubten keine Zuweisungen an R-Werte.	Ihr erstes Argument kann nur ein L-Wert sein.
LWG 352	C++98	X::state_type war nur als CopyConstructible erforderlich.	es muss auch als CopyAssignable und DefaultConstructible erforderlich sein.
LWG 3085	C++98	X::copy(s, p, n) forderte nur p nicht in [s, s + n), was zu schwach war.	fordert, dass [p, p + n) und [s, s + n) sich nicht überschneiden.