C++ named requirements: CharTraits

CharTraits est une classe de traits qui abstrait les opérations de base sur les caractères et les chaînes pour un type de caractère donné. La plupart des classes de chaînes et d'entrée/sortie de la bibliothèque standard requièrent un paramètre de type template CharTraits parallèlement à un paramètre de type template de caractère correspondant.

Table des matières 1 Exigences 2 Types 3 Expressions 4 Bibliothèque standard 4.1 Chaînes 4.2 Flux 4.3 Itérateurs de flux 4.4 Tampons de flux 4.5 Itérateurs de tampon de flux 5 Rapports de défauts

Exigences

Aucune opération listée ci-dessous sur CharTraits ne peut lever une exception.

Étant donné

• CharT , un type de caractère
• X , un type CharTraits pour le type CharT
• c , d , valeurs de type CharT
• p , q , valeurs de type const CharT *
• s , une valeur de type CharT*
• n , i , j , valeurs de type std::size_t
• e , f , valeurs de type X::int_type
• pos , une valeur de type X::pos_type
• state , une valeur de type X::state_type
• r , une lvalue de type CharT

Types

Type	Sémantique
X::char_type	CharT
X::int_type	Un type capable de contenir toutes les valeurs valides de X::char_type ainsi que X :: eof ( )
X::off_type	Comportement défini par l'implémentation si ce n'est pas std::streamoff lorsque X est utilisé comme paramètre de template traits dans les classes d'entrée/sortie.
X::pos_type	Les fonctions des classes d'entrée/sortie renvoyant ce type utilisent X :: pos_type ( X :: off_type ( - 1 ) ) comme valeur invalide pour signaler une erreur L'utilisation de cette valeur invalide comme argument à toute fonction membre de std::istream , std::ostream ou std::streambuf prenant une valeur de ce type est un comportement indéfini Comportement défini par l'implémentation si ce type n'est pas std::streampos lorsque X est utilisé comme paramètre de template traits dans les classes d'entrée/sortie
X::state_type	Destructible , CopyAssignable , CopyConstructible , DefaultConstructible

Expressions

Expression	Type de retour	Sémantique	Complexité
X :: eq ( c, d )	bool	Retourne : si c doit être considéré comme égal à d	Constant
X :: lt ( c, d )	bool	Retourne : si c doit être considéré comme inférieur à d	Constant
X :: compare ( p, q, n )	int	Retourne : ​ 0 ​ si pour chaque i dans [ ​ 0 ​ , n ) , X :: eq ( p [ i ] , q [ i ] ) est true Sinon, une valeur négative si Pour un certain j dans [ ​ 0 ​ , n ) , X :: lt ( p [ j ] , q [ j ] ) est true et Pour chaque i dans [ ​ 0 ​ , j ) , X :: eq ( p [ i ] , q [ i ] ) est true Sinon une valeur positive	Linéaire
X :: length ( p )	std::size_t	Retourne : le plus petit i tel que X :: eq ( p [ i ] , CharT ( ) ) soit true	Linéaire
X :: find ( p, n, c )	const X :: char_type *	Retourne : Le plus petit q dans [ p , p + n ) tel que X :: eq ( * q, c ) soit true ​ 0 ​ sinon	Linéaire
X :: move ( s, p, n )	X::char_type*	Pour chaque i dans [ ​ 0 ​ , n ) , effectue X :: assign ( s [ i ] , p [ i ] ) Copie correctement même lorsque les intervalles [ p , p + n ) et [ s , s + n ) se chevauchent Retourne : s	Linéaire
X :: copy ( s, p, n )	X::char_type*	Requiert : [ p , p + n ) et [ s , s + n ) ne se chevauchent pas Retourne : s Pour chaque i dans [ ​ 0 ​ , n ) , exécute X :: assign ( s [ i ] , p [ i ] )	Linéaire
X :: assign ( r, d )	(Non utilisé)	Assigne r = d	Constante
X :: assign ( s, n, c )	X::char_type*	Pour chaque i dans [ ​ 0 ​ , n ) , exécute X :: assign ( s [ i ] , c ) . Retourne : s	Linéaire
X :: not_eof ( e )	X::int_type	Retourne : e si X :: eq_int_type ( e, X :: eof ( ) ) est false Sinon une valeur f telle que X :: eq_int_type ( f, X :: eof ( ) ) est false	Constante
X :: to_char_type ( e )	X::char_type	Retourne : S'il existe un c tel que X :: eq_int_type ( e, X :: to_int_type ( c ) ) est true , c Sinon une valeur non spécifiée	Constante
X :: to_int_type ( c )	X::int_type	Retourne : une certaine valeur e , contrainte par les définitions de X::to_char_type et X::eq_int_type	Constante
X :: eq_int_type ( e, f )	bool	Pour tous c et d , X :: eq ( c, d ) est égal à X :: eq_int_type ( X :: to_int_type ( c ) , X :: to_int_type ( d ) ) Retourne : Donne X :: eq ( c, d ) si pour certains c et d , e == X :: to_int_type ( c ) et f == X :: to_int_type ( d ) Sinon, donne true si e et f sont tous deux des copies de X :: eof ( ) Sinon, donne false si l'un de e et f est une copie de X :: eof ( ) et l'autre ne l'est pas Sinon la valeur n'est pas spécifiée	Constante
X :: eof ( )	X::int_type	Retourne : une valeur e telle que X :: eq_int_type ( e, X :: to_int_type ( c ) ) est false pour toutes les valeurs c	Constante

Bibliothèque standard

CharTraits est requis par les modèles de classes de la bibliothèque standard suivants en tant que paramètre de type template :

Chaînes de caractères
basic_string	stocke et manipule des séquences de caractères (modèle de classe)
basic_string_view (C++17)	vue de chaîne en lecture seule (modèle de classe)
Flux
basic_ios	gère un tampon de flux arbitraire (modèle de classe)
basic_istream	encapsule un dispositif abstrait donné ( std::basic_streambuf ) et fournit une interface d'entrée de haut niveau (modèle de classe)
basic_ifstream	implémente les opérations d'entrée de flux de fichier de haut niveau (modèle de classe)
basic_istringstream	implémente les opérations d'entrée de flux de chaîne de haut niveau (modèle de classe)
basic_ispanstream (C++23)	implémente les opérations d'entrée sur tampon de caractères fixe (modèle de classe)
basic_ostream	encapsule un dispositif abstrait donné ( std::basic_streambuf ) et fournit une interface de sortie de haut niveau (modèle de classe)
basic_ofstream	implémente les opérations de sortie de flux de fichiers de haut niveau (modèle de classe)
basic_ostringstream	implémente les opérations de sortie de flux de chaîne de haut niveau (modèle de classe)
basic_osyncstream (C++20)	wrapper de flux de sortie synchronisé (modèle de classe)
basic_ospanstream (C++23)	implémente les opérations de sortie sur tampon de caractères fixe (modèle de classe)
basic_iostream	encapsule un dispositif abstrait donné ( std::basic_streambuf ) et fournit une interface d'entrée/sortie de haut niveau (modèle de classe)
basic_fstream	implémente les opérations d'entrée/sortie de flux de fichiers de haut niveau (modèle de classe)
basic_stringstream	implémente les opérations d'entrée/sortie de flux de chaînes de haut niveau (modèle de classe)
basic_spanstream (C++23)	implémente les opérations d'entrée/sortie sur tampon de caractères fixe (modèle de classe)
Itérateurs de flux
istream_iterator	itérateur d'entrée qui lit depuis std::basic_istream (modèle de classe)
ostream_iterator	itérateur de sortie qui écrit dans std::basic_ostream (modèle de classe)
Tampons de flux
basic_streambuf	abstrait un périphérique brut (modèle de classe)
basic_filebuf	implémente le périphérique de fichier brut (modèle de classe)
basic_stringbuf	implémente un périphérique de chaîne brut (modèle de classe)
basic_syncbuf (C++20)	enveloppe de périphérique de sortie synchronisé (modèle de classe)
basic_spanbuf (C++23)	implémente un périphérique de tampon de caractères brut fixe (modèle de classe)
Itérateurs de tampon de flux
istreambuf_iterator	itérateur d'entrée qui lit depuis std::basic_streambuf (modèle de classe)
ostreambuf_iterator	itérateur de sortie qui écrit vers std::basic_streambuf (modèle de classe)

CharTraits est satisfait par les spécialisations explicites suivantes de la bibliothèque standard de std::char_traits :

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 > ;		(depuis C++20) (depuis C++11) (depuis C++11)

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	Appliqué à	Comportement publié	Comportement corrigé
LWG 335	C++98	les exigences sur la surcharge binaire de assign n'empêchaient pas les assignations vers des rvalues	son premier argument ne peut être qu'un lvalue
LWG 352	C++98	X::state_type était seulement requis d'être CopyConstructible	il est également requis d'être CopyAssignable et DefaultConstructible
LWG 3085	C++98	X :: copy ( s, p, n ) exigeait seulement que p ne soit pas dans [ s , s + n ) , ce qui est trop faible [1]	exige que [ p , p + n ) et [ s , s + n ) ne se chevauchent pas

1. ↑ [ p , p + n ) et [ s , s + n ) peuvent se chevaucher, l'utilisation de std::memcpy pour implémenter X::copy entraîne un comportement indéfini dans ce cas.