Come posso convertire un doppio in una stringa in C ++?

Ho bisogno di memorizzare un doppio come una stringa. So che posso usare printf se volessi visualizzarlo, ma voglio solo memorizzarlo in una variabile stringa in modo che possa memorizzarlo in una mappa in un secondo momento (come valore , non come chiave ).

Il modo boost ™ :

 std::string str = boost::lexical_cast(dbl); 

Il modo standard C ++ :

 std::ostringstream strs; strs << dbl; std::string str = strs.str(); 

Nota : non dimenticare #include

 // The C way: char buffer[32]; snprintf(buffer, sizeof(buffer), "%g", myDoubleVar); // The C++03 way: std::ostringstream sstream; sstream << myDoubleVar; std::string varAsString = sstream.str(); // The C++11 way: std::string varAsString = std::to_string(myDoubleVar); // The boost way: std::string varAsString = boost::lexical_cast(myDoubleVar); 

Standard C ++ 11 (se non ti interessa il formato di output):

 #include  auto str = std::to_string(42.5); 

to_string è una nuova funzione di libreria introdotta in N1803 (r0), N1982 (r1) e N2408 (r2) ” Simple Numeric Access “. Ci sono anche la funzione stod per eseguire l’operazione inversa.

Se si desidera avere un formato di output diverso da "%f" , utilizzare i metodi snprintf o ostringstream come illustrato in altre risposte.

Se usi C ++, evita sprintf . È un-C ++ y e ha diversi problemi. Le stringhe sono il metodo di scelta, preferibilmente incapsulato come in Boost.LexicalCast che può essere fatto abbastanza facilmente:

 template  std::string to_string(T const& value) { stringstream sstr; sstr << value; return sstr.str(); } 

Uso:

 string s = to_string(42.5); 

Puoi usare std :: to_string in C ++ 11

 double d = 3.0; std::string str = std::to_string(d); 

sprintf va bene, ma in C ++, il modo migliore, più sicuro e leggermente più lento per fare la conversione è con stringstream :

 #include  #include  // In some function: double d = 453.23; std::ostringstream os; os << d; std::string str = os.str(); 

Puoi anche utilizzare Boost.LexicalCast :

 #include  #include  // In some function: double d = 453.23; std::string str = boost::lexical_cast(d); 

In entrambi i casi, str dovrebbe essere "453.23" seguito. LexicalCast presenta alcuni vantaggi nel garantire che la trasformazione sia completa. Usa stringstream internamente.

Vorrei dare un’occhiata alla libreria C ++ String Toolkit . Ho appena pubblicato una risposta simile altrove. L’ho trovato molto veloce e affidabile.

 #include  double pi = M_PI; std::string pi_as_string = strtk::type_to_string( pi ); 

Herb Sutter ha un eccellente articolo sulla formattazione delle stringhe . Consiglio di leggerlo. L’ho collegato prima su SO.

Il problema con lexical_cast è l’incapacità di definire la precisione. Normalmente se stai convertendo un doppio in una stringa, è perché vuoi stamparlo. Se la precisione è troppo o troppo poco, ciò influenzerebbe l’output.

Puoi anche usare stringstream .

Heh, ho appena scritto questo (non correlato a questa domanda):

 string temp = ""; stringstream outStream; double ratio = (currentImage->width*1.0f)/currentImage->height; outStream << " R: " << ratio; temp = outStream.str(); /* rest of the code */ 

Puoi leggere il mio post precedente su SO. (Versione a macroistruzione con un object stringstream temporaneo.)

Per la cronaca: nel mio codice, preferisco snprintf (). Con un array di caratteri nello stack locale, non è così inefficiente. (Beh, forse se hai superato la dimensione dell’array e fatto un ciclo per farlo due volte …)

(L’ho anche impacchettato via vsnprintf () .Ma questo mi costa qualche tipo di controllo. Yelp se vuoi il codice …)

Normalmente per queste operazioni devi usare le funzioni ecvt, fcvt o gcvt:

 /* gcvt example */ #include  #include  main () { char buffer [20]; gcvt (1365.249,6,buffer); puts (buffer); gcvt (1365.249,3,buffer); puts (buffer); return 0; } Output: 1365.25 1.37e+003 

Come una funzione:

 void double_to_char(double f,char * buffer){ gcvt(f,10,buffer); } 

Dai un’occhiata a sprintf() e famiglia.

Potresti provare uno stile più compatto:

 std::string number_in_string; double number_in_double; std::ostringstream output; number_in_string = (dynamic_cast< std::ostringstream*>(&(output << number_in_double << std::endl)))->str(); 

Usa to_string() .
esempio :

 #include  #include  using namespace std; int main () { string pi = "pi is " + to_string(3.1415926); cout<< "pi = "<< pi << endl; return 0; } 

eseguilo da solo: http://ideone.com/7ejfaU
Questi sono anche disponibili:

 string to_string (int val); string to_string (long val); string to_string (long long val); string to_string (unsigned val); string to_string (unsigned long val); string to_string (unsigned long long val); string to_string (float val); string to_string (double val); string to_string (long double val); 

Puoi convertire qualsiasi cosa in qualcosa usando questa funzione:

 template T to(U a) { std::stringstream ss; T ret; ss << a; ss >> ret; return ret; }; 

utilizzo:

 std::string str = to(2.5); double d = to("2.5");