Se recomienda usar Visual Studio 2017

char_traits (Struct)

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

La estructura char_traits describe los atributos asociados a un carácter.

template <class CharType>  
struct char_traits;  

Parámetros

CharType
Tipo de datos del elemento.

La estructura de plantilla describe varios rasgos de caracteres de tipo CharType. La clase de plantilla basic_string , así como varias clases de plantilla de iostream, incluidas basic_ios, utilizar esta información para manipular los elementos de tipo CharType. Un tipo de elemento de este tipo no debe requerir ni una construcción ni una destrucción explícita. Debe proporcionar un constructor predeterminado, un constructor de copias y un operador de asignación, con la semántica esperada. Una copia bit a bit debe tener el mismo efecto que una asignación. Ninguna de las funciones miembro de la estructura char_traits puede iniciar excepciones.

Definiciones de tipo

char_typeUn tipo de carácter.
int_typeTipo entero que puede representar un carácter de tipo char_type o un carácter de final de archivo (EOF).
off_typeTipo entero que puede representar desplazamientos entre posiciones de una secuencia.
pos_typeTipo entero que puede representar posiciones de una secuencia.
state_typeTipo que representa el estado de conversión de caracteres multibyte de una secuencia.

Funciones miembro

asignarAsigna un valor de carácter a otro.
compararCompara un número especificado de caracteres de dos cadenas.
copiaCopia un número especificado de caracteres de una cadena a otra. Desusado. Utilice char_traits:: _copy_s en su lugar.
_Copy_sCopia un número especificado de caracteres de una cadena a otra.
EOFDevuelve el carácter de final de archivo (EOF).
EQComprueba si dos caracteres char_type son iguales.
eq_int_typeComprueba si dos caracteres que se representan como int_type son iguales.
BuscarBusca la primera aparición de un carácter especificado en un intervalo de caracteres.
longitudDevuelve la longitud de una cadena.
ltComprueba si un carácter es menor que otro.
moverCopia un número especificado de caracteres de una secuencia en otra secuencia que puede que esté superpuesta. Desusado. Utilice char_traits:: _move_s en su lugar.
_Move_sCopia un número especificado de caracteres de una secuencia en otra secuencia que puede que esté superpuesta.
not_eofComprueba si un carácter es el carácter de final de archivo (EOF).
to_char_typeConvierte un carácter int_type en el carácter char_type correspondiente y devuelve el resultado.
to_int_typeConvierte un carácter char_type en el carácter int_type correspondiente y devuelve el resultado.

Encabezado:<>>

Espacio de nombres: std

Asigna un valor de carácter a otro o a un intervalo de elementos de una cadena.

static void assign(char_type& _CharTo,
    const char_type& _CharFrom);

static char_type *assign(char_type* strTo,
    size_t _Num,
    char_type _CharFrom);

Parámetros

_ CharFrom
El carácter cuyo valor está asignado.

_CharTo
El elemento que se asigna el valor de carácter.

  • strTo *
    La matriz de cadena o un carácter cuyos elementos iniciales se asignará valores de caracteres.

_Num
El número de elementos que se van a asignar valores.

Valor devuelto

La segunda función miembro devuelve un puntero a la cadena cuyo primer _Num elementos se han asignado valores de _CharFrom.

Ejemplo

// char_traits_assign.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )   
{  
   using namespace std;  
  
   // The first member function assigning   
   // one character value to another character  
   char ChTo = 't';  
   const char ChFrom = 'f';  
   cout << "The initial characters ( ChTo , ChFrom ) are: ( "  
        << ChTo << " , " << ChFrom << " )." << endl;  
   char_traits<char>::assign ( ChTo , ChFrom );  
   cout << "After assigning, the characters ( ChTo , ChFrom ) are: ( "  
        << ChTo << " , " << ChFrom << " )." << endl << endl;  
  
   // The second member function assigning   
   // character values to initial part of a string  
   char_traits<char>::char_type s1[] = "abcd-1234-abcd";  
   char_traits<char>::char_type* result1;  
   cout << "The target string s1 is: " << s1 << endl;  
   result1 = char_traits<char>::assign ( s1 , 4 , 'f' );  
   cout << "The result1 = assign ( s1 , 4 , 'f' ) is: "  
        << result1 << endl;  
}  

The initial characters ( ChTo , ChFrom ) are: ( t , f ).  
After assigning, the characters ( ChTo , ChFrom ) are: ( f , f ).  
  
The target string s1 is: abcd-1234-abcd  
The result1 = assign ( s1 , 4 , 'f' ) is: ffff-1234-abcd  

Un tipo de carácter.

typedef CharType char_type;  

Comentarios

El tipo es un sinónimo del parámetro de plantilla CharType.

Ejemplo

Vea el ejemplo de copia para obtener un ejemplo de cómo declarar y utilizar char_type.

Compara un número especificado de caracteres de dos cadenas.

static int compare(const char_type* str1,
    const char_type* str2,
    size_t _Num);

Parámetros

  • str1 *
    El primero de dos cadenas se va a comparar entre sí.

  • str2 *
    El segundo de dos cadenas se va a comparar entre sí.

_Num
El número de elementos en las cadenas que se va a comparar.

Valor devuelto

Un valor negativo si la primera cadena es menor que la segunda cadena de, 0 si las dos cadenas son iguales, o un valor positivo si la primera cadena es mayor que la segunda cadena.

Comentarios

Se realiza la comparación entre las cadenas de elemento por elemento, comprobar la igualdad en primer lugar y, a continuación, si un par de elementos de la secuencia de pruebas distinto, se ha probado menor.

Si dos cadenas son iguales en un intervalo pero uno más que el otro, entonces el más corto de los dos es menor que el mayor.

Ejemplo

// char_traits_compare.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main() {  
   using namespace std;  
  
   char_traits<char>::char_type* s1 = "CAB";  
   char_traits<char>::char_type* s2 = "ABC";  
   char_traits<char>::char_type* s3 = "ABC";  
   char_traits<char>::char_type* s4 = "ABCD";  
  
   cout << "The string s1 is: " << s1 << endl;  
   cout << "The string s2 is: " << s2 << endl;  
   cout << "The string s3 is: " << s3 << endl;  
   cout << "The string s4 is: " << s4 << endl;  
  
   int comp1, comp2, comp3, comp4;  
   comp1 = char_traits<char>::compare ( s1 , s2 , 2 );  
   comp2 = char_traits<char>::compare ( s2 , s3 , 3 );  
   comp3 = char_traits<char>::compare ( s3 , s4 , 4 );  
   comp4 = char_traits<char>::compare ( s4 , s3 , 4 );  
   cout << "compare ( s1 , s2 , 2 ) = " << comp1 << endl;  
   cout << "compare ( s2 , s3 , 3 ) = " << comp2 << endl;  
   cout << "compare ( s3 , s4 , 4 ) = " << comp3 << endl;  
   cout << "compare ( s4 , s3 , 4 ) = " << comp4 << endl;  
}  

Copia un número especificado de caracteres de una cadena a otra.

Este método es potencialmente inseguro, ya que se basa en el llamador para comprobar que los valores pasados son correctos. Considere el uso de char_traits:: _copy_s en su lugar.

static char_type *copy(char_type* _To,
    const char_type* _From,
    size_t _Num);

Parámetros

_To
El elemento situado al principio de la matriz de cadena o un carácter como destinada para recibir la secuencia de caracteres copiada.

_From
El elemento situado al principio de la matriz de cadena o un carácter de origen se copien.

_Num
El número de elementos copiados.

Valor devuelto

El primer elemento que se copian en la matriz de cadena o un carácter como destinada para recibir la secuencia de caracteres copiada.

Comentarios

Las secuencias de caracteres de origen y de destino no deben superponerse.

Ejemplo

// char_traits_copy.cpp  
// compile with: /EHsc /W3  
#include <string>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
  
   char_traits<char>::char_type s1[] = "abcd-1234-abcd";  
   char_traits<char>::char_type s2[] = "ABCD-1234";  
   char_traits<char>::char_type* result1;  
   cout << "The source string is: " << s1 << endl;  
   cout << "The destination string is: " << s2 << endl;  
   // Note: char_traits::copy is potentially unsafe, consider  
   // using char_traits::_Copy_s instead.  
   result1 = char_traits<char>::copy ( s1 , s2 , 4 );  // C4996  
   cout << "The result1 = copy ( s1 , s2 , 4 ) is: "  
        << result1 << endl;  
}  

The source string is: abcd-1234-abcd  
The destination string is: ABCD-1234  
The result1 = copy ( s1 , s2 , 4 ) is: ABCD-1234-abcd  

Copia un número especificado de caracteres de una cadena a otra.

static char_type *_Copy_s(
    char_type* dest,  
    size_t dest_size,  
    const char_type* _From,  
    size_t count);

Parámetros

dest
La matriz de cadena o un carácter como destinada para recibir la secuencia de caracteres copiada.

dest_size
El tamaño de dest. Si char_type es char, a continuación, se muestra el tamaño en bytes. Si char_type es wchar_t, entonces este tamaño es en palabras.

_From
Carácter o cadena de matriz de origen que se va a copiar.

count
El número de elementos copiados.

Valor devuelto

La matriz de cadena o un carácter como destinada para recibir la secuencia de caracteres copiada.

Comentarios

Las secuencias de caracteres de origen y de destino no deben superponerse.

Ejemplo

// char_traits__Copy_s.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )  
{  
    using namespace std;  
  
    char_traits<char>::char_type s1[] = "abcd-1234-abcd";  
    char_traits<char>::char_type s2[] = "ABCD-1234";  
    char_traits<char>::char_type* result1;  
    cout << "The source string is: " << s1 << endl;  
    cout << "The destination string is: " << s2 << endl;  
    result1 = char_traits<char>::_Copy_s(s1,  
        char_traits<char>::length(s1), s2, 4);  
    cout << "The result1 = _Copy_s(s1, "  
         << "char_traits<char>::length(s1), s2, 4) is: "  
         << result1 << endl;  
}  

The source string is: abcd-1234-abcd  
The destination string is: ABCD-1234  
The result1 = _Copy_s(s1, char_traits<char>::length(s1), s2, 4) is: ABCD-1234-abcd  

Devuelve el carácter de final de archivo (EOF).

static int_type eof();

Valor devuelto

El carácter EOF.

Comentarios

Un valor que representa el final del archivo (como EOF o WEOF).

Los Estados estándares de C++ que este valor no debe corresponder a una char_type valor. El compilador de Visual C++ exige esta restricción para el tipo char, pero no para el tipo wchar_t. En el ejemplo siguiente se muestra esto.

Ejemplo

// char_traits_eof.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main()  
{  
    using namespace std;  
  
    char_traits<char>::char_type ch1 = 'x';  
    char_traits<char>::int_type int1;  
    int1 = char_traits<char>::to_int_type(ch1);  
    cout << "char_type ch1 is '" << ch1 << "' and corresponds to int_type "  
         << int1 << "." << endl << endl;  
  
    char_traits<char>::int_type int2 = char_traits<char>::eof();  
    cout << "The eof marker for char_traits<char> is: " << int2 << endl;  
  
    char_traits<wchar_t>::int_type int3 = char_traits<wchar_t>::eof();  
    cout << "The eof marker for char_traits<wchar_t> is: " << int3 << endl;  
}  

char_type ch1 is 'x' and corresponds to int_type 120.  
  
The eof marker for char_traits<char> is: -1  
The eof marker for char_traits<wchar_t> is: 65535  

Comprueba si dos caracteres char_type son iguales.

static bool eq(const char_type& _Ch1, const char_type& _Ch2);

Parámetros

_Ch1
El primero de dos caracteres para las pruebas de igualdad.

_Ch2
El segundo de dos caracteres para las pruebas de igualdad.

Valor devuelto

True si el primer carácter es igual que el segundo carácter; en caso contrario false.

Ejemplo

// char_traits_eq.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )   
{  
   using namespace std;  
  
   char_traits<char>::char_type ch1 =  'x';  
   char_traits<char>::char_type ch2 =  'y';  
   char_traits<char>::char_type ch3 =  'x';  
  
   // Testing for equality  
   bool b1 = char_traits<char>::eq ( ch1 , ch2 );  
   if ( b1 )  
      cout << "The character ch1 is equal "  
           << "to the character ch2." << endl;  
   else  
      cout << "The character ch1 is not equal "  
           << "to the character ch2." << endl;  
  
   // An equivalent and alternatively test procedure  
   if ( ch1 == ch3 )  
      cout << "The character ch1 is equal "  
           << "to the character ch3." << endl;  
   else  
      cout << "The character ch1 is not equal "  
           << "to the character ch3." << endl;  
}  

The character ch1 is not equal to the character ch2.  
The character ch1 is equal to the character ch3.  

Comprueba si dos caracteres se representan como int_types son iguales o no.

static bool eq_int_type(const int_type& _Ch1, const int_type& _Ch2);

Parámetros

_Ch1
El primero de los dos caracteres se va a probar la igualdad como int_types.

_Ch2
El segundo de los dos caracteres que se va a probar la igualdad como int_types.

Valor devuelto

True si el primer carácter es igual que el segundo carácter; en caso contrario false.

Ejemplo

// char_traits_eq_int_type.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
  
   char_traits<char>::char_type ch1 =  'x';  
   char_traits<char>::char_type ch2 =  'y';  
   char_traits<char>::char_type ch3 =  'x';  
  
   // Converting from char_type to int_type  
   char_traits<char>::int_type int1, int2 , int3;  
   int1 =char_traits<char>:: to_int_type ( ch1 );  
   int2 =char_traits<char>:: to_int_type ( ch2 );  
   int3 =char_traits<char>:: to_int_type ( ch3 );  
  
   cout << "The char_types and corresponding int_types are:"  
        << "\n    ch1 = " << ch1 << " corresponding to int1 = "  
        << int1 << "."  
        << "\n    ch2 = " << ch2 << " corresponding to int1 = "  
        << int2 << "."  
        << "\n    ch3 = " << ch3 << " corresponding to int1 = "  
        << int3 << "." << endl << endl;  
  
   // Testing for equality of int_type representations  
   bool b1 = char_traits<char>::eq_int_type ( int1 , int2 );  
   if ( b1 )  
      cout << "The int_type representation of character ch1\n "  
           << "is equal to the int_type representation of ch2."  
           << endl;  
   else  
      cout << "The int_type representation of character ch1\n is "  
           << "not equal to the int_type representation of ch2."  
           << endl;  
  
   // An equivalent and alternatively test procedure  
   if ( int1 == int3 )  
      cout << "The int_type representation of character ch1\n "  
           << "is equal to the int_type representation of ch3."  
           << endl;  
   else  
      cout << "The int_type representation of character ch1\n is "  
           << "not equal to the int_type representation of ch3."  
           << endl;  
}  

The char_types and corresponding int_types are:  
    ch1 = x corresponding to int1 = 120.  
    ch2 = y corresponding to int1 = 121.  
    ch3 = x corresponding to int1 = 120.  
  
The int_type representation of character ch1  
 is not equal to the int_type representation of ch2.  
The int_type representation of character ch1  
 is equal to the int_type representation of ch3.  

Busca la primera aparición de un carácter especificado en un intervalo de caracteres.

static const char_type* find(const char_type* str,
    size_t _Num,
    const char_type& _Ch);

Parámetros

str
El primer carácter de la cadena que se va a buscar.

_Num
El número de posiciones, contando desde el principio, en el intervalo que se buscará.

_Ch
El carácter que se va a buscar en el intervalo.

Valor devuelto

Un puntero a la primera aparición del carácter especificado en el intervalo si se encuentra una coincidencia; de lo contrario, un puntero nulo.

Ejemplo

// char_traits_find.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )   
{  
   using namespace std;  
  
   const char* s1 = "f2d-1234-abcd";  
   const char* result1;  
   cout << "The string to be searched is: " << s1 << endl;  
  
   // Searching for a 'd' in the first 6 positions of string s1  
   result1 = char_traits<char>::find ( s1 , 6 , 'd');  
   cout << "The character searched for in s1 is: "  
        << *result1 << endl;  
   cout << "The string beginning with the first occurrence\n "  
        << "of the character 'd' is: " << result1 << endl;  
  
   // When no match is found the NULL value is returned  
   const char* result2;  
   result2 = char_traits<char>::find ( s1 , 3 , 'a');  
   if ( result2 == NULL )  
      cout << "The result2 of the search is NULL." << endl;  
   else  
      cout << "The result2 of the search  is: " << result1  
           << endl;  
}  

The string to be searched is: f2d-1234-abcd  
The character searched for in s1 is: d  
The string beginning with the first occurrence  
 of the character 'd' is: d-1234-abcd  
The result2 of the search is NULL.  

Tipo entero que puede representar un carácter de tipo char_type o un carácter de final de archivo (EOF).

typedef long int_type;  

Comentarios

Debe ser posible escribir un valor de tipo de conversión CharType a int_type , a continuación, volver a CharType sin modificar el valor original.

Ejemplo

Vea el ejemplo de eq_int_type para obtener un ejemplo de cómo declarar y utilizar int_type.

Devuelve la longitud de una cadena.

static size_t length(const char_type* str);

Parámetros

str
La cadena de C es cuya longitud se va a medir.

Valor devuelto

El número de elementos de la secuencia que se está midiendo no incluido el terminador null.

Ejemplo

// char_traits_length.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )   
{  
   using namespace std;  
   const char* str1= "Hello";  
   cout << "The C-string str1 is: " << str1 << endl;  
  
   size_t lenStr1;  
   lenStr1 = char_traits<char>::length ( str1 );  
   cout << "The length of C-string str1 is: "   
        << lenStr1 << "." << endl;  
}  

The C-string str1 is: Hello  
The length of C-string str1 is: 5.  

Comprueba si un carácter es menor que otro.

static bool lt(const char_type& _Ch1, const char_type& _Ch2);

Parámetros

_Ch1
El primero de dos caracteres se va a probar menor.

_Ch2
El segundo de dos caracteres que se va a probar menor.

Valor devuelto

True si el primer carácter es menor que el segundo carácter; en caso contrario false.

Ejemplo

// char_traits_lt.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )   
{  
   using namespace std;  
   char_traits<char>::char_type ch1 =  'x';  
   char_traits<char>::char_type ch2 =  'y';  
   char_traits<char>::char_type ch3 =  'z';  
  
   // Testing for less than  
   bool b1 = char_traits<char>::lt ( ch1 , ch2 );  
   if ( b1 )  
      cout << "The character ch1 is less than "  
           << "the character ch2." << endl;  
   else  
      cout << "The character ch1 is not less "  
           << "than the character ch2." << endl;  
  
   // An equivalent and alternatively test procedure  
   if ( ch3 <  ch2 )  
      cout << "The character ch3 is less than "  
           << "the character ch2." << endl;  
   else  
      cout << "The character ch3 is not less "  
           << "than the character ch2." << endl;  
}  

The character ch1 is less than the character ch2.  
The character ch3 is not less than the character ch2.  

Copia un número especificado de caracteres de una secuencia a otro, posiblemente superpuestas secuencia.

Este método es potencialmente inseguro, ya que se basa en el llamador para comprobar que los valores pasados son correctos. Considere el uso de char_traits:: _move_s en su lugar.

static char_type *move(char_type* _To,
    const char_type* _From,
    size_t _Num);

Parámetros

_To
El elemento situado al principio de la matriz de cadena o un carácter como destinada para recibir la secuencia de caracteres copiada.

_From
El elemento situado al principio de la matriz de cadena o un carácter de origen se copien.

_Num
El número de elementos que se copian de la cadena de origen.

Valor devuelto

El primer elemento _To copia en la matriz de cadena o un carácter como destinada para recibir la secuencia de caracteres copiada.

Comentarios

El origen y destino se pueden superponer.

Ejemplo

// char_traits_move.cpp  
// compile with: /EHsc /W3  
#include <string>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
  
   char_traits<char>::char_type sFrom1[] =  "abcd-1234-abcd";  
   char_traits<char>::char_type sTo1[] =  "ABCD-1234";  
   char_traits<char>::char_type* result1;  
   cout << "The source string sFrom1 is: " << sFrom1 << endl;  
   cout << "The destination stringsTo1 is: " << sTo1 << endl;  
   // Note: char_traits::move is potentially unsafe, consider  
   // using char_traits::_Move_s instead.  
   result1 = char_traits<char>::move ( sTo1 ,  sFrom1 , 4 );  // C4996  
   cout << "The result1 = move ( sTo1 , sFrom1 , 4 ) is: "  
        << result1 << endl << endl;  
  
   // When source and destination overlap  
   char_traits<char>::char_type sToFrom2[] = "abcd-1234-ABCD";  
   char_traits<char>::char_type* result2;  
   cout << "The source/destination string sToFrom2 is: "  
        << sToFrom2 << endl;  
   const char* findc = char_traits<char>::find ( sToFrom2 , 4 , 'c' );  
   // Note: char_traits::move is potentially unsafe, consider  
   // using char_traits::_Move_s instead.  
   result2 = char_traits<char>::move ( sToFrom2 , findc , 8 );  // C4996  
   cout << "The result2 = move ( sToFrom2 , findc , 8 ) is: "  
        << result2 << endl;  
}  

The source string sFrom1 is: abcd-1234-abcd  
The destination stringsTo1 is: ABCD-1234  
The result1 = move ( sTo1 , sFrom1 , 4 ) is: abcd-1234  
  
The source/destination string sToFrom2 is: abcd-1234-ABCD  
The result2 = move ( sToFrom2 , findc , 8 ) is: cd-1234-4-ABCD  

Copia un número especificado de caracteres de una secuencia a otro, posiblemente superpuestas secuencia.

static char_type *_Move_s(
    char_type* dest,  
    size_t dest_size,  
    const char_type* _From,  
    size_t count);

Parámetros

dest
El elemento situado al principio de la matriz de cadena o un carácter como destinada para recibir la secuencia de caracteres copiada.

dest_size
El tamaño de dest. Si char_type es char, esto es, en bytes. Si char_type es wchar_t, a continuación, se trata en palabras.

_From
El elemento situado al principio de la matriz de cadena o un carácter de origen se copien.

count
El número de elementos que se copian de la cadena de origen.

Valor devuelto

El primer elemento dest copia en la matriz de cadena o un carácter como destinada para recibir la secuencia de caracteres copiada.

Comentarios

El origen y destino se pueden superponer.

Ejemplo

// char_traits__Move_s.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )  
{  
    using namespace std;  
  
    char_traits<char>::char_type sFrom1[] =  "abcd-1234-abcd";  
    char_traits<char>::char_type sTo1[] =  "ABCD-1234";  
    char_traits<char>::char_type* result1;  
    cout << "The source string sFrom1 is: " << sFrom1 << endl;  
    cout << "The destination stringsTo1 is: " << sTo1 << endl;  
    result1 = char_traits<char>::_Move_s(sTo1,  
        char_traits<char>::length(sTo1), sFrom1, 4);  
    cout << "The result1 = _Move_s(sTo1, "  
         << "char_traits<char>::length(sTo1), sFrom1, 4) is: "  
         << result1 << endl << endl;  
  
    // When source and destination overlap  
    char_traits<char>::char_type sToFrom2[] = "abcd-1234-ABCD";  
    char_traits<char>::char_type* result2;  
    cout << "The source/destination string sToFrom2 is: "  
         << sToFrom2 << endl;  
    const char* findc = char_traits<char>::find(sToFrom2, 4, 'c');  
    result2 = char_traits<char>::_Move_s(sToFrom2,  
        char_traits<char>::length(sToFrom2), findc, 8);  
    cout << "The result2 = _Move_s(sToFrom2, "  
        << "char_traits<char>::length(sToFrom2), findc, 8) is: "  
         << result2 << endl;  
}  

The source string sFrom1 is: abcd-1234-abcd  
The destination stringsTo1 is: ABCD-1234  
The result1 = _Move_s(sTo1, char_traits<char>::length(sTo1), sFrom1, 4) is: abcd-1234  
  
The source/destination string sToFrom2 is: abcd-1234-ABCD  
The result2 = _Move_s(sToFrom2, char_traits<char>::length(sToFrom2), findc, 8) is: cd-1234-4-ABCD  

Comprueba si un carácter no es el carácter de fin de archivo (EOF) o es el final del archivo.

static int_type not_eof(const int_type& _Ch);

Parámetros

_Ch
El carácter representado como un int_type se va a probar si es el carácter EOF o no.

Valor devuelto

El int_type probado de representación del carácter, si la int_type del carácter no es igual que el del carácter EOF.

Si el carácter int_type valor es igual a la EOF int_type valor, a continuación, false.

Ejemplo

// char_traits_not_eof.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( ) {  
   using namespace std;  
  
   char_traits<char>::char_type ch1 =  'x';  
   char_traits<char>::int_type int1;  
   int1 = char_traits<char>:: to_int_type ( ch1 );  
   cout << "The char_type ch1 is " << ch1  
        << " corresponding to int_type: "   
        << int1 << "." << endl;  
  
   // EOF member function  
   char_traits <char>::int_type int2 = char_traits<char>::eof ( );  
   cout << "The eofReturn is: " << int2 << endl;  
  
   // Testing for EOF or another character  
   char_traits <char>::int_type eofTest1, eofTest2;  
   eofTest1 = char_traits<char>::not_eof ( int1 );  
   if ( !eofTest1 )  
      cout << "The eofTest1 indicates ch1 is an EOF character."  
              << endl;  
   else  
      cout << "The eofTest1 returns: " << eofTest1   
           << ", which is the character: "   
           <<  char_traits<char>::to_char_type ( eofTest1 )  
           << "." << endl;  
  
   eofTest2 = char_traits<char>::not_eof ( int2 );  
   if ( !eofTest2 )  
      cout << "The eofTest2 indicates int2 is an EOF character."   
           << endl;  
   else  
      cout << "The eofTest1 returns: " << eofTest2   
           << ", which is the character: "   
           <<  char_traits<char>::to_char_type ( eofTest2 )   
           << "." << endl;  
}  

The char_type ch1 is x corresponding to int_type: 120.  
The eofReturn is: -1  
The eofTest1 returns: 120, which is the character: x.  
The eofTest2 indicates int2 is an EOF character.  

Tipo entero que puede representar desplazamientos entre posiciones de una secuencia.

typedef streamoff off_type;  

Comentarios

El tipo es un entero con signo que describe un objeto que puede almacenar un desplazamiento de bytes implicados en secuencia varias operaciones de posición. Normalmente es un sinónimo de streamoff, pero tiene esencialmente las mismas propiedades que ese tipo.

Tipo entero que puede representar posiciones de una secuencia.

typedef streampos pos_type;  

Comentarios

El tipo describe un objeto que puede almacenar toda la información necesaria para restaurar un indicador de posición de archivo arbitrario dentro de una secuencia. Normalmente es un sinónimo de streampos, pero en cualquier caso tiene esencialmente las mismas propiedades que ese tipo.

Tipo que representa el estado de conversión de caracteres multibyte en una secuencia.

typedef implementation-defined state_type;  

Comentarios

El tipo describe un objeto que puede representar un estado de conversión. Normalmente es un sinónimo de mbstate_t, pero en cualquier caso tiene esencialmente las mismas propiedades que ese tipo.

Convierte un carácter int_type en el carácter char_type correspondiente y devuelve el resultado.

static char_type to_char_type(const int_type& _Ch);

Parámetros

_Ch
El int_type caracteres para ser representado como un char_type.

Valor devuelto

El char_type carácter correspondiente a la int_type caracteres.

Un valor de _Ch que no se puede representar como tal produce un resultado no especificado.

Comentarios

Las operaciones de conversión to_int_type y to_char_type son inversas entre sí, por lo que:

to_int_type( to_char_type ( x ) ) == x

for any int_type x and

to_char_type( to_int_type ( x ) ) == x

for any char_type x.

Ejemplo

// char_traits_to_char_type.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )   
{  
   using namespace std;  
  
   char_traits<char>::char_type ch1 =  'a';  
   char_traits<char>::char_type ch2 =  'b';  
   char_traits<char>::char_type ch3 =  'a';  
  
   // Converting from char_type to int_type  
   char_traits<char>::int_type int1, int2 , int3;  
   int1 =char_traits<char>:: to_int_type ( ch1 );  
   int2 =char_traits<char>:: to_int_type ( ch2 );  
   int3 =char_traits<char>:: to_int_type ( ch3 );  
  
   cout << "The char_types and corresponding int_types are:"  
        << "\n    ch1 = " << ch1 << " corresponding to int1 = "   
        << int1 << "."  
        << "\n    ch2 = " << ch2 << " corresponding to int1 = "   
        << int2 << "."  
        << "\n    ch3 = " << ch3 << " corresponding to int1 = "   
        << int3 << "." << endl << endl;  
  
   // Converting from int_type back to char_type  
   char_traits<char>::char_type rec_ch1;  
   rec_ch1 = char_traits<char>:: to_char_type ( int1);  
   char_traits<char>::char_type rec_ch2;  
   rec_ch2 = char_traits<char>:: to_char_type ( int2);  
  
   cout << "The recovered char_types and corresponding int_types are:"  
        << "\n    recovered ch1 = " << rec_ch1 << " from int1 = "   
        << int1 << "."  
        << "\n    recovered ch2 = " << rec_ch2 << " from int2 = "   
        << int2 << "." << endl << endl;  
  
   // Testing that the conversions are inverse operations  
   bool b1 = char_traits<char>::eq ( rec_ch1 , ch1 );  
   if ( b1 )  
      cout << "The recovered char_type of ch1"  
           << " is equal to the original ch1." << endl;  
   else  
      cout << "The recovered char_type of ch1"  
           << " is not equal to the original ch1." << endl;  
  
   // An equivalent and alternatively test procedure  
   if ( rec_ch2 == ch2 )  
      cout << "The recovered char_type of ch2"  
           << " is equal to the original ch2." << endl;  
   else  
      cout << "The recovered char_type of ch2"  
           << " is not equal to the original ch2." << endl;  
}  

The char_types and corresponding int_types are:  
    ch1 = a corresponding to int1 = 97.  
    ch2 = b corresponding to int1 = 98.  
    ch3 = a corresponding to int1 = 97.  
  
The recovered char_types and corresponding int_types are:  
    recovered ch1 = a from int1 = 97.  
    recovered ch2 = b from int2 = 98.  
  
The recovered char_type of ch1 is equal to the original ch1.  
The recovered char_type of ch2 is equal to the original ch2.  

Convierte un carácter char_type en el carácter int_type correspondiente y devuelve el resultado.

static int_type to_int_type(const char_type& _Ch);

Parámetros

_Ch
El char_type caracteres para ser representado como un int_type.

Valor devuelto

El int_type carácter correspondiente a la char_type caracteres.

Comentarios

Las operaciones de conversión to_int_type y to_char_type son inversas entre sí, por lo que:

to_int_type( to_char_type ( x ) ) == x

for any int_type x, and

to_char_type( to_int_type ( x ) ) == x

for any char_type x.

Ejemplo

// char_traits_to_int_type.cpp  
// compile with: /EHsc  
#include <string>  
#include <iostream>  
  
int main( )   
{  
   using namespace std;  
   char_traits<char>::char_type ch1 = 'a';  
   char_traits<char>::char_type ch2 = 'b';  
   char_traits<char>::char_type ch3 = 'a';  
  
   // Converting from char_type to int_type  
   char_traits<char>::int_type int1, int2 , int3;  
   int1 =char_traits<char>:: to_int_type ( ch1 );  
   int2 =char_traits<char>:: to_int_type ( ch2 );  
   int3 =char_traits<char>:: to_int_type ( ch3 );  
  
   cout << "The char_types and corresponding int_types are:"  
        << "\n    ch1 = " << ch1 << " corresponding to int1 = "   
        << int1 << "."  
        << "\n    ch2 = " << ch2 << " corresponding to int1 = "   
        << int2 << "."  
        << "\n    ch3 = " << ch3 << " corresponding to int1 = "   
        << int3 << "." << endl << endl;  
  
   // Converting from int_type back to char_type  
   char_traits<char>::char_type rec_ch1;  
   rec_ch1 = char_traits<char>:: to_char_type ( int1);  
   char_traits<char>::char_type rec_ch2;  
   rec_ch2 = char_traits<char>:: to_char_type ( int2);  
  
   cout << "The recovered char_types and corresponding int_types are:"  
        << "\n    recovered ch1 = " << rec_ch1 << " from int1 = "   
        << int1 << "."  
        << "\n    recovered ch2 = " << rec_ch2 << " from int2 = "   
        << int2 << "." << endl << endl;  
  
   // Testing that the conversions are inverse operations  
   bool b1 = char_traits<char>::eq ( rec_ch1 , ch1 );  
   if ( b1 )  
      cout << "The recovered char_type of ch1"  
           << " is equal to the original ch1." << endl;  
   else  
      cout << "The recovered char_type of ch1"  
           << " is not equal to the original ch1." << endl;  
  
   // An equivalent and alternatively test procedure  
   if ( rec_ch2 == ch2 )  
      cout << "The recovered char_type of ch2"  
           << " is equal to the original ch2." << endl;  
   else  
      cout << "The recovered char_type of ch2"  
           << " is not equal to the original ch2." << endl;  
}  

The char_types and corresponding int_types are:  
    ch1 = a corresponding to int1 = 97.  
    ch2 = b corresponding to int1 = 98.  
    ch3 = a corresponding to int1 = 97.  
  
The recovered char_types and corresponding int_types are:  
    recovered ch1 = a from int1 = 97.  
    recovered ch2 = b from int2 = 98.  
  
The recovered char_type of ch1 is equal to the original ch1.  
The recovered char_type of ch2 is equal to the original ch2.  

Seguridad para subprocesos en la biblioteca estándar de C++

Mostrar: