Struct char_traits

La struct char_traits descrive gli attributi associati a un carattere.

Sintassi

template <class CharType>
struct char_traits;

Parametri

CharType
Tipo di dati elemento.

Osservazioni:

Lo struct modello descrive vari tratti di carattere per il tipo CharType. Il modello di classe basic_string nonché diversi modelli di classe iostream, tra cui basic_ios, usare queste informazioni per modificare gli elementi di tipo CharType. Un elemento di questo tipo non deve richiedere una costruzione o una distruzione esplicita. Deve fornire un costruttore predefinito, un costruttore di copia e un operatore di assegnazione con la semantica prevista. Una copia bit per bit deve avere lo stesso effetto di un'assegnazione. Nessuna delle funzioni membro di struct char_traits può generare eccezioni.

Typedef

Nome tipo	Descrizione
char_type	Tipo di carattere.
int_type	Un tipo Integer che può rappresentare un carattere di tipo char_type o un carattere EOF.
off_type	Un tipo Integer che può rappresentare offset tra posizioni in un flusso.
pos_type	Un tipo Integer che può rappresentare posizioni in un flusso.
state_type	Tipo che rappresenta lo stato di conversione per caratteri multibyte in un flusso.

Funzioni membro

Funzione membro	Descrizione
assign	Assegna un valore del carattere a un altro.
compare	Confronta un numero specificato di caratteri in due stringhe.
copy	Copia un numero specificato di caratteri da una stringa a un'altra. Deprecato. Usare invece char_traits::_Copy_s.
_Copy_s	Copia un numero specificato di caratteri da una stringa a un'altra.
eof	Restituisce il carattere EOF.
eq	Verifica se due caratteri char_type sono uguali.
eq_int_type	Verifica se due caratteri rappresentati come int_type sono uguali.
find	Cerca la prima occorrenza di un carattere specificato in un intervallo di caratteri.
length	Restituisce la lunghezza di una stringa.
lt	Verifica se un carattere è minore di un altro.
move	Copia un numero specificato di caratteri in una sequenza in un'altra sequenza possibile di sovrapposizione. Deprecato. Usare invece char_traits::_Move_s.
_Move_s	Copia un numero specificato di caratteri in una sequenza in un'altra sequenza possibile di sovrapposizione.
not_eof	Verifica se un carattere è il carattere EOF.
to_char_type	Converte un carattere int_type in quello char_type corrispondente e restituisce il risultato.
to_int_type	Converte un carattere char_type in quello int_type corrispondente e restituisce il risultato.

Requisiti

Header:<string>

Spazio dei nomi: std

char_traits::assign

Assegna un valore del carattere a un altro elemento o un intervallo di elementi in una stringa.

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

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

Parametri

_ CharFrom Il carattere il cui valore deve essere assegnato.

_CharTo
L'elemento a cui deve essere assegnato il valore del carattere.

strTo
Stringa o matrice di caratteri ai cui elementi iniziali devono essere assegnati i valori dei caratteri.

_Num
Il numero di elementi a cui verranno assegnati i valori.

Valore restituito

La seconda funzione membro restituisce un puntatore alla stringa i cui primi elementi _Num sono stati assegnati valori di _CharFrom.

Esempio

// 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

char_traits::char_type

Tipo di carattere.

typedef CharType char_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello CharType.

Esempio

Vedere l'esempio di copy per informazioni su come dichiarare e usare char_type.

char_traits::compare

Confronta un numero specificato di caratteri in due stringhe.

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

Parametri

str1
La prima di due stringhe da confrontare tra loro.

str2
La seconda di due stringhe da confrontare tra loro.

_Num
Il numero di elementi nelle stringhe da confrontare.

Valore restituito

Un valore negativo se la prima stringa è minore della seconda stringa, 0 se le due stringhe sono uguali o un valore positivo se la prima stringa è maggiore della seconda stringa.

Osservazioni:

Il confronto tra le stringhe viene eseguito elemento per elemento, testando prima l'uguaglianza, quindi, se in una coppia di elementi della sequenza risulta una disuguaglianza, vengono testate per stabilire qual è la minore.

Se due stringhe risultano uguali in un intervallo, ma una è più lunga dell'altra, la più corta delle due è minore di quella più lunga.

Esempio

// 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;
}

char_traits::copy

Copia un numero specificato di caratteri da una stringa a un'altra.

Questo metodo è potenzialmente non sicuro, poiché si basa sul chiamante per verificare che i valori passati siano corretti. È preferibile usare char_traits::_Copy_s.

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

Parametri

_A
L'elemento all'inizio della matrice di stringhe o caratteri che deve ricevere la sequenza di caratteri copiata.

_Da
L'elemento all'inizio della matrice di stringhe o caratteri di origine da copiare.

_Num
Il numero di elementi da copiare.

Valore restituito

Il primo elemento copiato nella matrice di stringhe o caratteri che deve ricevere la sequenza di caratteri copiata.

Osservazioni:

Le sequenze di caratteri di origine e di destinazione non devono sovrapporsi.

Esempio

// 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

char_traits::_Copy_s

Copia un numero specificato di caratteri da una stringa a un'altra.

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

Parametri

dest
La matrice di stringhe o caratteri che deve ricevere la sequenza di caratteri copiata.

dest_size
Dimensione del dest. Se char_type è char, questa dimensione è espressa in byte. Se char_type è wchar_t, questa dimensione è espressa in parole.

_Da
La matrice di stringhe o caratteri di origine da copiare.

count
Il numero di elementi da copiare.

Valore restituito

La matrice di stringhe o caratteri che deve ricevere la sequenza di caratteri copiata.

Osservazioni:

Le sequenze di caratteri di origine e di destinazione non devono sovrapporsi.

Esempio

// 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

char_traits::eof

Restituisce il carattere EOF.

static int_type eof();

Valore restituito

Il carattere EOF.

Osservazioni:

Valore che rappresenta la fine del file, ad esempio EOF o WEOF.

Lo standard C++ stabilisce che questo valore non deve corrispondere a un valore char_type valido. Il compilatore Microsoft C++ applica questo vincolo per il tipo char, ma non per il tipo wchar_t. Nell'esempio che segue viene illustrato quanto descritto.

Esempio

// 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

char_traits::eq

Verifica se due caratteri char_type sono uguali.

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

Parametri

_Ch1
Il primo di due caratteri di cui verificare l'uguaglianza.

_Ch2
Il secondo di due caratteri di cui verificare l'uguaglianza.

Valore restituito

true se il primo carattere è uguale al secondo carattere; in caso contrario false, .

Esempio

// 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.

char_traits::eq_int_type

Verifica se due caratteri rappresentati come int_type sono uguali.

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

Parametri

_Ch1
Primo dei due caratteri da testare per verificare l'uguaglianza come int_types.

_Ch2
Il secondo di due caratteri di cui verificare l'uguaglianza come int_type.

Valore restituito

true se il primo carattere è uguale al secondo carattere; in caso contrario false, .

Esempio

// 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.

char_traits::find

Cerca la prima occorrenza di un carattere specificato in un intervallo di caratteri.

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

Parametri

str
Il primo carattere della stringa in cui verrà eseguita la ricerca.

_Num
Il numero di posizioni, contando dalla prima, nell'intervallo in cui verrà eseguita la ricerca.

_Ch
Il carattere da cercare nell'intervallo.

Valore restituito

Un puntatore alla prima occorrenza del carattere specificato nell'intervallo se viene trovata una corrispondenza. In caso contrario, un puntatore Null.

Esempio

// 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.

char_traits::int_type

Un tipo Integer che può rappresentare un carattere di tipo char_type o un carattere EOF.

typedef long int_type;

Osservazioni:

È necessario digitare il cast di un valore di tipo CharType a e quindi tornare a CharType int_type senza modificare il valore originale.

Esempio

Vedere l'esempio relativo a eq_int_type per informazioni su come dichiarare e usare int_type.

char_traits::length

Restituisce la lunghezza di una stringa.

static size_t length(const char_type* str);

Parametri

str
Stringa C di cui si misura la lunghezza.

Valore restituito

Il numero di elementi della sequenza misurati, escluso il carattere di terminazione NULL.

Esempio

// 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.

char_traits::lt

Verifica se un carattere è minore di un altro.

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

Parametri

_Ch1
Il primo di due caratteri confrontati per verificare qual è il minore.

_Ch2
Il secondo di due caratteri confrontati per verificare qual è il minore.

Valore restituito

true se il primo carattere è minore del secondo carattere; in caso contrario false, .

Esempio

// 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.

char_traits::move

Copia un numero specificato di caratteri di una sequenza in un'altra sequenza che potrebbe sovrapporsi.

Questo metodo è potenzialmente non sicuro, poiché si basa sul chiamante per verificare che i valori passati siano corretti. È preferibile usare char_traits::_Move_s.

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

Parametri

_A
L'elemento all'inizio della matrice di stringhe o caratteri che deve ricevere la sequenza di caratteri copiata.

_Da
L'elemento all'inizio della matrice di stringhe o caratteri di origine da copiare.

_Num
Il numero di elementi da copiare dalla stringa di origine.

Valore restituito

Il primo elemento _To copiato nella stringa o nella matrice di caratteri di destinazione per ricevere la sequenza di caratteri copiata.

Osservazioni:

L'origine e la destinazione possono sovrapporsi.

Esempio

// 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

char_traits::_Move_s

Copia un numero specificato di caratteri di una sequenza in un'altra sequenza che potrebbe sovrapporsi.

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

Parametri

dest
L'elemento all'inizio della matrice di stringhe o caratteri che deve ricevere la sequenza di caratteri copiata.

dest_size
Dimensione del dest. Se char_type è char, il valore è espresso in byte. Se char_type è wchar_t, il valore è espresso in parole.

_Da
L'elemento all'inizio della matrice di stringhe o caratteri di origine da copiare.

count
Il numero di elementi da copiare dalla stringa di origine.

Valore restituito

Primo elemento copiato nella stringa o nella matrice di caratteri di destinazione per ricevere la sequenza di caratteri copiata.

Osservazioni:

L'origine e la destinazione possono sovrapporsi.

Esempio

// 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

char_traits::not_eof

Verifica se un carattere è il carattere EOF (fine del file) o non lo è.

static int_type not_eof(const int_type& _Ch);

Parametri

_Ch
Il carattere rappresentato come int_type da testare per verificare se è o non è il carattere EOF.

Valore restituito

Rappresentazione int_type del carattere testato, se l'oggetto int_type del carattere non è uguale a quello del carattere EOF.

Se il valore del carattere int_type è uguale al valore EOF int_type , false.

Esempio

// 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.

char_traits::off_type

Un tipo Integer che può rappresentare offset tra posizioni in un flusso.

typedef streamoff off_type;

Osservazioni:

Il tipo è un intero con segno che descrive un oggetto in grado di archiviare un offset di byte interessato da varie operazioni di posizionamento del flusso. In genere è un sinonimo di streamoff e ha essenzialmente le stesse proprietà di quel tipo.

char_traits::p os_type

Un tipo Integer che può rappresentare posizioni in un flusso.

typedef streampos pos_type;

Osservazioni:

Il tipo descrive un oggetto in grado di archiviare tutte le informazioni necessarie per ripristinare un indicatore di posizione del file arbitrario all'interno di un flusso. In genere è un sinonimo di streampos e in ogni caso ha essenzialmente le stesse proprietà di quel tipo.

char_traits::state_type

Tipo che rappresenta lo stato di conversione per i caratteri multibyte in un flusso.

typedef implementation-defined state_type;

Osservazioni:

Il tipo descrive un oggetto che può rappresentare uno stato di conversione. In genere è un sinonimo di mbstate_t e in ogni caso ha essenzialmente le stesse proprietà di quel tipo.

char_traits::to_char_type

Converte un carattere int_type in quello char_type corrispondente e restituisce il risultato.

static char_type to_char_type(const int_type& _Ch);

Parametri

_Ch
Il carattere int_type da rappresentare come char_type.

Valore restituito

Il carattere char_type corrispondente al carattere int_type.

Un valore di _Ch che non può essere rappresentato come tale restituisce un risultato non specificato.

Osservazioni:

Le operazioni di conversione to_int_type e to_char_type sono l'una l'inverso dell'altra, in modo che:

to_int_type ( to_char_type ( x ) ) == x

per qualsiasi int_type x e

to_char_type ( to_int_type ( x ) ) == x

per qualsiasi char_type x.

Esempio

// 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.

char_traits::to_int_type

Converte un carattere char_type in quello int_type corrispondente e restituisce il risultato.

static int_type to_int_type(const char_type& _Ch);

Parametri

_Ch
Il carattere char_type da rappresentare come int_type.

Valore restituito

Il carattere int_type corrispondente al carattere char_type.

Osservazioni:

Le operazioni di conversione to_int_type e to_char_type sono l'una l'inverso dell'altra, in modo che:

to_int_type ( to_char_type ( x ) ) == x

per qualsiasi int_type x e

to_char_type ( to_int_type ( x ) ) == x

per qualsiasi char_type x.

Esempio

// 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.

Vedi anche

Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)