C++ named requirements: CharTraits

CharTraits es una clase de rasgos que abstrae las operaciones básicas de caracteres y cadenas para un tipo de carácter dado. La mayoría de las clases de cadena y entrada/salida de la biblioteca estándar requieren un CharTraits parámetro de tipo plantilla junto con un parámetro de tipo plantilla de carácter correspondiente.

Contenidos 1 Requisitos 2 Tipos 3 Expresiones 4 Biblioteca estándar 4.1 Cadenas 4.2 Flujos 4.3 Iteradores de flujo 4.4 Búferes de flujo 4.5 Iteradores de búfer de flujo 5 Informes de defectos

Requisitos

Ninguna operación listada a continuación en CharTraits puede lanzar una excepción.

Dado

• CharT , un tipo de carácter
• X , un tipo CharTraits para el tipo CharT
• c , d , valores de tipo CharT
• p , q , valores de tipo const CharT *
• s , un valor de tipo CharT*
• n , i , j , valores de tipo std::size_t
• e , f , valores de tipo X::int_type
• pos , un valor de tipo X::pos_type
• state , un valor de tipo X::state_type
• r , un lvalue de tipo CharT

Tipos

Tipo	Semántica
X::char_type	CharT
X::int_type	Un tipo que puede contener todos los valores válidos de X::char_type más X :: eof ( )
X::off_type	Invoca comportamiento definido por la implementación si no es std::streamoff cuando X se utiliza como parámetro de plantilla traits en clases de entrada/salida.
X::pos_type	Las funciones en clases de entrada/salida que devuelven este tipo utilizan X :: pos_type ( X :: off_type ( - 1 ) ) como un valor inválido para indicar un error El uso de este valor inválido como argumento para cualquier miembro de std::istream , std::ostream o std::streambuf que tome un valor de este tipo es comportamiento indefinido Invoca comportamiento definido por la implementación si este tipo no es std::streampos cuando X se utiliza como parámetro de plantilla traits en clases de entrada/salida
X::state_type	Destructible , CopyAssignable , CopyConstructible , DefaultConstructible

Expresiones

Expresión	Tipo de retorno	Semántica	Complejidad
X :: eq ( c, d )	bool	Retorna: si c debe tratarse como igual a d	Constante
X :: lt ( c, d )	bool	Retorna: si c debe tratarse como menor que d	Constante
X :: compare ( p, q, n )	int	Retorna: ​ 0 ​ si para cada i en [ ​ 0 ​ , n ) , X :: eq ( p [ i ] , q [ i ] ) es true En caso contrario, un valor negativo si Para algún j en [ ​ 0 ​ , n ) , X :: lt ( p [ j ] , q [ j ] ) es true y Para cada i en [ ​ 0 ​ , j ) , X :: eq ( p [ i ] , q [ i ] ) es true En caso contrario un valor positivo	Lineal
X :: length ( p )	std::size_t	Devuelve: el menor i tal que X :: eq ( p [ i ] , CharT ( ) ) sea true	Lineal
X :: find ( p, n, c )	const X :: char_type *	Retorna: El menor q en [ p , p + n ) tal que X :: eq ( * q, c ) sea true ​ 0 ​ en caso contrario	Lineal
X :: move ( s, p, n )	X::char_type*	Para cada i en [ ​ 0 ​ , n ) , ejecuta X :: assign ( s [ i ] , p [ i ] ) Copia correctamente incluso cuando los rangos [ p , p + n ) y [ s , s + n ) se superponen Retorna: s	Lineal
X :: copy ( s, p, n )	X::char_type*	Requisitos: [ p , p + n ) y [ s , s + n ) no se superpongan Retorna: s Para cada i en [ ​ 0 ​ , n ) , ejecuta X :: assign ( s [ i ] , p [ i ] )	Lineal
X :: assign ( r, d )	(No utilizado)	Asigna r = d	Constante
X :: assign ( s, n, c )	X::char_type*	Para cada i en [ ​ 0 ​ , n ) , ejecuta X :: assign ( s [ i ] , c ) . Retorna: s	Lineal
X :: not_eof ( e )	X::int_type	Retorna: e si X :: eq_int_type ( e, X :: eof ( ) ) es false En caso contrario, un valor f tal que X :: eq_int_type ( f, X :: eof ( ) ) es false	Constante
X :: to_char_type ( e )	X::char_type	Retorna: Si para algún c , X :: eq_int_type ( e, X :: to_int_type ( c ) ) es true , c Sino algún valor no especificado	Constante
X :: to_int_type ( c )	X::int_type	Retorna: algún valor e , restringido por las definiciones de X::to_char_type y X::eq_int_type	Constante
X :: eq_int_type ( e, f )	bool	Para todo c y d , X :: eq ( c, d ) es igual a X :: eq_int_type ( X :: to_int_type ( c ) , X :: to_int_type ( d ) ) Retorna: Produce X :: eq ( c, d ) si para algún c y d , e == X :: to_int_type ( c ) y f == X :: to_int_type ( d ) En caso contrario, produce true si e y f son ambos copias de X :: eof ( ) En caso contrario, produce false si uno de e y f es una copia de X :: eof ( ) y el otro no En otro caso, el valor no está especificado	Constante
X :: eof ( )	X::int_type	Retorna: un valor e tal que X :: eq_int_type ( e, X :: to_int_type ( c ) ) es false para todos los valores c	Constante

Biblioteca estándar

CharTraits es requerido por las siguientes plantillas de clase de la biblioteca estándar como un parámetro de tipo de plantilla:

Cadenas
basic_string	almacena y manipula secuencias de caracteres (plantilla de clase)
basic_string_view (C++17)	vista de cadena de solo lectura (plantilla de clase)
Flujos
basic_ios	gestiona un búfer de flujo arbitrario (plantilla de clase)
basic_istream	envuelve un dispositivo abstracto dado ( std::basic_streambuf ) y proporciona una interfaz de entrada de alto nivel (plantilla de clase)
basic_ifstream	implementa operaciones de entrada de flujo de archivos de alto nivel (plantilla de clase)
basic_istringstream	implementa operaciones de entrada de flujo de cadena de alto nivel (plantilla de clase)
basic_ispanstream (C++23)	implementa operaciones de entrada con búfer de caracteres fijo (plantilla de clase)
basic_ostream	envuelve un dispositivo abstracto dado ( std::basic_streambuf ) y proporciona una interfaz de salida de alto nivel (plantilla de clase)
basic_ofstream	implementa operaciones de salida de flujo de archivos de alto nivel (plantilla de clase)
basic_ostringstream	implementa operaciones de salida de flujo de cadena de alto nivel (plantilla de clase)
basic_osyncstream (C++20)	envoltura de flujo de salida sincronizado (plantilla de clase)
basic_ospanstream (C++23)	implementa operaciones de salida de búfer de caracteres fijo (plantilla de clase)
basic_iostream	envuelve un dispositivo abstracto dado ( std::basic_streambuf ) y proporciona una interfaz de entrada/salida de alto nivel (plantilla de clase)
basic_fstream	implementa operaciones de entrada/salida de flujo de archivos de alto nivel (plantilla de clase)
basic_stringstream	implementa operaciones de entrada/salida de flujo de cadena de alto nivel (plantilla de clase)
basic_spanstream (C++23)	implementa operaciones de entrada/salida con búfer de caracteres fijo (plantilla de clase)
Iteradores de flujo
istream_iterator	iterador de entrada que lee desde std::basic_istream (plantilla de clase)
ostream_iterator	iterador de salida que escribe a std::basic_ostream (plantilla de clase)
Búferes de flujo
basic_streambuf	abstrae un dispositivo sin procesar (plantilla de clase)
basic_filebuf	implementa dispositivo de archivo sin formato (plantilla de clase)
basic_stringbuf	implementa dispositivo de cadena sin formato (plantilla de clase)
basic_syncbuf (C++20)	envoltorio de dispositivo de salida sincronizado (plantilla de clase)
basic_spanbuf (C++23)	implementa un dispositivo de búfer de caracteres fijo sin formato (plantilla de clase)
Iteradores de búfer de flujo
istreambuf_iterator	iterador de entrada que lee desde std::basic_streambuf (plantilla de clase)
ostreambuf_iterator	iterador de salida que escribe en std::basic_streambuf (plantilla de clase)

CharTraits es satisfecho por las siguientes especializaciones explícitas de la biblioteca estándar 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 > ;		(desde C++20) (desde C++11) (desde C++11)

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 335	C++98	los requisitos de la sobrecarga binaria de assign no prevenían asignaciones a rvalues	su primer argumento solo puede ser un lvalue
LWG 352	C++98	X::state_type solo se requería que fuera CopyConstructible	también se requiere que sea CopyAssignable y DefaultConstructible
LWG 3085	C++98	X :: copy ( s, p, n ) solo requería que p no estuviera en [ s , s + n ) , lo cual es demasiado débil [1]	requiere que [ p , p + n ) y [ s , s + n ) no se solapen

1. ↑ [ p , p + n ) y [ s , s + n ) pueden superponerse. Usar std::memcpy para implementar X::copy resulta en comportamiento indefinido en este caso.