Il modo più semplice per convertire int in string in C ++

Qual è il modo più semplice per convertire da int a string equivalente in C ++. Sono a conoscenza di due metodi. C’è un modo più semplice?

(1)

 int a = 10; char *intStr = itoa(a); string str = string(intStr); 

(2)

 int a = 10; stringstream ss; ss << a; string str = ss.str(); 

C ++ 11 introduce std::stoi (e varianti per ogni tipo numerico) e std::to_string , le controparti di C atoi e itoa ma espresse in termini di std::string .

 #include  std::string s = std::to_string(42); 

è quindi il modo più breve che riesco a pensare. Puoi anche omettere di nominare il tipo, usando la parola chiave auto :

 auto s = std::to_string(42); 

Nota: vedi [string.conversions] ( 21.5 in n3242 )

Raccogliendo una discussione con @ v.oddou un paio di anni dopo, C ++ 17 ha finalmente fornito un modo per fare la soluzione agnostica di tipo originariamente basata su macro (conservata sotto) senza passare attraverso la macabria della macro.

 template < typename... Args > std::string sstr( Args &&... args ) { std::ostringstream sstr; ( sstr < < std::dec << ... << args ); return sstr.str(); } 

Uso:

 int i = 42; std::string s = sstr( "i is: ", i ); puts( sstr( i ).c_str() ); Foo x( 42 ); throw std::runtime_error( sstr( "Foo is '", x, "', i is ", i ) ); 

Risposta originale:

Poiché "convertire ... in stringa" è un problema ricorrente, definisco sempre la macro SSTR () in un'intestazione centrale dei miei sorgenti C ++:

 #include  #define SSTR( x ) static_cast< std::ostringstream & >( \ ( std::ostringstream() < < std::dec << x ) ).str() 

L'utilizzo è facile come potrebbe essere:

 int i = 42; std::string s = SSTR( "i is: " < < i ); puts( SSTR( i ).c_str() ); Foo x( 42 ); throw std::runtime_error( SSTR( "Foo is '" << x << "', i is " << i ) ); 

Quanto sopra è compatibile con C ++ 98 (se non puoi usare C ++ 11 std::to_string ), e non ha bisogno di std::to_string terze parti (se non puoi usare Boost lexical_cast<> ); entrambe queste altre soluzioni hanno comunque prestazioni migliori.

Di solito uso il seguente metodo:

 #include  template  std::string NumberToString ( T Number ) { std::ostringstream ss; ss < < Number; return ss.str(); } 

descritto in dettaglio qui .

Probabilmente il modo più semplice è quello di avvolgere essenzialmente la tua seconda scelta in un modello chiamato lexical_cast , come quello in Boost , quindi il tuo codice è simile al seguente:

 int a = 10; string s = lexical_cast(a); 

Una buona parte di questo è che supporta anche altri cast (ad esempio, nella direzione opposta funziona altrettanto bene).

Si noti inoltre che, sebbene Boost lexical_cast sia iniziato come una semplice scrittura su uno stringstream, quindi si estrae nuovamente dallo stream, ora ha un paio di aggiunte. Prima di tutto, sono state aggiunte specializzazioni per diversi tipi, quindi per molti tipi comuni, è sostanzialmente più veloce rispetto all’utilizzo di uno stringstream. Secondo, ora controlla il risultato, quindi (per esempio) se si converte da una stringa a una int , si può generare un’eccezione se la stringa contiene qualcosa che non può essere convertito in un int (ad esempio, 1234 avrebbe avuto successo, ma 123abc avrebbe gettato).

A partire da C ++ 11, c’è una funzione std::to_string sovraccaricata per i tipi interi, quindi puoi usare un codice come:

 int a = 20; std::string s = to_string(a); 

Lo standard definisce questi come equivalenti a fare la conversione con sprintf (usando lo specificatore di conversione che corrisponde al tipo di object fornito, come %d per int ), in un buffer di dimensioni sufficienti, quindi creando una std::string contenuto di quel buffer

Se hai installato Boost (che dovresti):

 #include  int num = 4; std::string str = boost::lexical_cast(num); 

Non sarebbe più semplice usare i diagrammi?

 #include  int x=42; //The integer string str; //The string ostringstream temp; //temp as in temporary temp<  

Oppure fai una funzione:

 #include  string IntToString (int a) { ostringstream temp; temp<  

Non che io sappia, in puro C ++. Ma una piccola modifica di ciò che hai menzionato

 string s = string(itoa(a)); 

dovrebbe funzionare, ed è piuttosto breve.

sprintf() è abbastanza buono per la conversione del formato. Puoi quindi assegnare la stringa C risultante alla stringa C ++ come hai fatto in 1.

Primo include:

 #include  #include  

Secondo aggiungere il metodo:

 template  string NumberToString(T pNumber) { ostringstream oOStrStream; oOStrStream < < pNumber; return oOStrStream.str(); } 

Usa il metodo in questo modo:

 NumberToString(69); 

o

 int x = 69; string vStr = NumberToString(x) + " Hello word!." 

Puoi usare std::to_string disponibile in C ++ 11 come suggerito da Matthieu M .:

 std::to_string(42); 

Oppure, se le prestazioni sono fondamentali (ad esempio, se si eseguono molte conversioni), è ansible utilizzare fmt::FormatInt dalla libreria di formato C ++ per convertire un numero intero in std::string :

 fmt::FormatInt(42).str(); 

O una stringa C:

 fmt::FormatInt f(42); f.c_str(); 

Quest’ultimo non fa allocazioni di memoria dynamic ed è più di 10 volte più veloce di std::to_string sui benchmark di Boost Karma. Vedi Fast integer per convertire le stringhe in C ++ per maggiori dettagli.

A differenza di std::to_string , fmt::FormatInt non richiede C ++ 11 e funziona con qualsiasi compilatore C ++.

Disclaimer: sono l’autore della libreria di formato C ++.

Usare lo stringstream per la conversione del numero è pericoloso!

Vedere http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/ dove indica che l’ operator< < inserisce l'output formattato.

A seconda delle impostazioni locali correnti, un numero intero maggiore di 3 cifre potrebbe essere convertito in una stringa di 4 cifre, aggiungendo un separatore extra di migliaia.

Ad esempio, int = 1000 potrebbe essere convertito in una stringa 1.001 . Ciò potrebbe rendere le operazioni di confronto non funzionanti affatto.

Quindi consiglio vivamente di usare la modalità std::to_string . È più facile e fa quello che ti aspetti.

Per C ++ 98 , ci sono alcune opzioni:

boost/lexical_cast

Boost non fa parte della libreria C ++, ma contiene molte estensioni della libreria utili.

Il modello di funzione lexical_cast offre una forma comoda e coerente per supportare le conversioni comuni da e verso tipi arbitrari quando sono rappresentati come testo.
– Boost’s Documentation

 #include "boost/lexical_cast.hpp" #include  int main() { int x = 5; std::string x_str = boost::lexical_cast(x); return 0; } 

Per quanto riguarda il runtime, l’operazione lexical_cast impiega circa 80 microsecondi (sulla mia macchina) alla prima conversione, quindi accelera considerevolmente in seguito se eseguita in modo ridondante.


itoa

Questa funzione non è definita in ANSI-C e non fa parte di C ++, ma è supportata da alcuni compilatori.
– cplusplus.com

Ciò significa che gcc / g++ non può compilare il codice usando itoa .

 #include  int main() { int x = 5; char * x_str = new char[2]; x_str = itoa(x, x_str, 10); // base 10 return 0; } 

Nessun runtime da segnalare. Non ho installato Visual Studio, che è riferito in grado di compilare itoa .


sprintf

sprintf è una funzione di libreria standard C che funziona con le stringhe C ed è un’alternativa perfettamente valida.

Compone una stringa con lo stesso testo che verrebbe stampata se il formato fosse usato su printf, ma invece di essere stampato, il contenuto è memorizzato come una stringa C nel buffer puntato da str.
– cplusplus.com

 #include  int main() { int x = 5; char * x_str = new char[2]; int chars_written = sprintf(x_str, "%d", x); return 0; } 

L’intestazione stdio.h potrebbe non essere necessaria. Per quanto riguarda il runtime, l’operazione sprintf impiega circa 40 microsecondi (sulla mia macchina) alla prima conversione, per poi accelerare considerevolmente in seguito se eseguita in modo ridondante.


stringstream

Questo è il modo principale della libreria C ++ per convertire gli interi in stringhe e viceversa. Esistono altre funzioni simili a stringstream che limitano ulteriormente l’uso previsto del stream, come ad esempio ostringstream . L’uso di ostringstream dice espressamente al lettore del tuo codice che intendi solo utilizzare l’operatore < < , in sostanza. Questa funzione è tutto ciò che è particolarmente necessario per convertire un intero in una stringa. Vedi questa domanda per una discussione più elaborata.

 #include  #include  int main() { int x = 5; std::ostringstream stream; stream < < x; std::string x_str = stream.str(); return 0; } 

Per quanto riguarda il runtime, l'operazione ostringstream impiega circa 71 microsecondi (sulla mia macchina), per poi accelerare considerevolmente in seguito se eseguita in modo ridondante, ma non tanto quanto le funzioni precedenti .


Ovviamente ci sono altre opzioni, e puoi persino inserire una di queste nella tua funzione, ma questo offre uno sguardo analitico ad alcuni di quelli popolari.

Uso:

 #define convertToString(x) #x int main() { convertToString(42); // Returns const char* equivalent of 42 } 

È piuttosto semplice aggiungere dello zucchero sintattico che consente di comporre stringhe al volo in un modo simile al stream

 #include  #include  struct strmake { std::stringstream s; template  strmake& operator < < (const T& x) { s << x; return *this; } operator std::string() {return s.str();} }; 

Ora puoi aggiungere qualunque cosa tu voglia (ammesso che un operatore < < (std::ostream& ..) sia definito per esso) a strmake() e usarlo al posto di uno std::string .

Esempio:

 #include  int main() { std::string x = strmake() < < "Current time is " << 5+5 << ":" << 5*5 << " GST"; std::cout << x << std::endl; } 
 namespace std { inline string to_string(int _Val) { // convert long long to string char _Buf[2 * _MAX_INT_DIG]; snprintf(_Buf, "%d", _Val); return (string(_Buf)); } } 

ora puoi usare to_string(5)

Io uso:

 int myint = 0; long double myLD = 0.0; string myint_str = static_cast( &(ostringstream() < < myint) )->str(); string myLD_str = static_cast( &(ostringstream() < < myLD) )->str(); 

Funziona con i miei compilatori windows e linux g ++.

Utilizzando CString :

 int a = 10; CString strA; strA.Format("%d", a); 
 string number_to_string(int x){ if(!x) return "0"; string s,s2; while(x){ s.push_back(x%10 + '0'); x/=10; } reverse(s.begin(),s.end()); return s; } 
 #include "stdafx.h" #include #include #include std::string intToString(int num); int main() { int integer = 4782151; std::string integerAsStr = intToString(integer); std::cout < < "integer = " << integer << std::endl; std::cout << "integerAsStr = " << integerAsStr << std::endl; return 0; } std::string intToString(int num) { std::string numAsStr; while (num) { char toInsert = (num % 10) + 48; numAsStr.insert(0, 1, toInsert); num /= 10; } return numAsStr; } 
 char * bufSecs = new char[32]; char * bufMs = new char[32]; sprintf(bufSecs,"%d",timeStart.elapsed()/1000); sprintf(bufMs,"%d",timeStart.elapsed()%1000); 

Se hai bisogno di convertire velocemente un numero intero con un numero fisso di cifre in char * lasciato con “0”, questo è un esempio pratico:

 int n = 27; char s[8]; 

Se stai convertendo un numero a due cifre:

 *(int32_t*)s = 0x3030 | (n/10) | (n%10) < < 8; 

Se stai convertendo un numero a tre cifre:

 *(int32_t*)s = 0x303030 | (n/100) | (n/10%10) < < 8 | (n%10) << 16; 

Se si sta convertendo un numero a quattro cifre:

 *(int64_t*)s = 0x30303030 | (n/1000) | (n/100%10)< <8 | (n/10%10)<<16 | (n%10)<<24; 

E così via fino a numeri a sette cifre 🙂

Ecco un altro modo semplice per fare

 char str[100] ; sprintf(str , "%d" , 101 ) ; string s = str; 

sprintf è ben noto per inserire qualsiasi dato in una stringa di formato richiesto.

È ansible convertire l’array char * in stringa come mostrato nella terza riga.

 int n = 123; std::string str = std::to_string(n); 

Si utilizza un tipo di contatore di algoritmo per convertire in una stringa. Ho ottenuto questa tecnica dalla programmazione dei computer Commodore 64 . È anche un bene per la programmazione di giochi.

  • Prendi il numero intero e prendi ogni cifra che è ponderata con i poteri di 10. Quindi supponi che il numero intero sia 950.

    • Se il numero intero è uguale o superiore a 100.000, sottrarre 100.000 e aumentare il contatore nella stringa a [“000000”];
      continua a farlo fino a quando non ci saranno più numeri in posizione 100.000. Lascia un altro potere di dieci

    • Se il numero intero è uguale o maggiore di 10.000, sottrarre 10.000 e aumentare il contatore nella stringa a [“000000”] + 1 posizione;
      continua a farlo fino a quando non ci saranno più numeri in posizione 10.000.

  • Lascia un altro potere di dieci

  • Ripeti il ​​modello

So che 950 è troppo piccolo per essere usato come esempio, ma spero che tu abbia l’idea.