Come faccio a convertire un doppio in una stringa in C ++?

Devo memorizzare un doppio come stringa. So che posso usarlo printfse volessi visualizzarlo, ma voglio solo memorizzarlo in una variabile stringa in modo da poterlo archiviare in una mappa in un secondo momento (come valore , non come chiave ).

Il modo boost (tm) :

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

Il modo C ++ standard :

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

Nota : non dimenticare#include <sstream>

// 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<std::string>(myDoubleVar);

Il modo standard C ++ 11 (se non ti interessa il formato di output):

#include <string>

auto str = std::to_string(42.5); 

to_stringè una nuova funzione di libreria introdotta in N1803 (r0), N1982 (r1) e N2408 (r2) " Accesso numerico semplice ". Ci sono anche le stodfunzioni per eseguire l'operazione inversa.

Se si desidera avere un formato di output diverso rispetto a "%f", utilizzare i metodi snprintfo ostringstreamcome illustrato in altre risposte.

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

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

Uso:

string s = to_string(42.5);

È possibile utilizzare std :: to_string in C ++ 11

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

sprintfva bene, ma in C ++, il modo migliore, più sicuro e anche leggermente più lento di fare la conversione è con stringstream:

#include <sstream>
#include <string>

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

Puoi anche usare Boost.LexicalCast :

#include <boost/lexical_cast.hpp>
#include <string>

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

In entrambi i casi, strdovrebbe essere "453.23"dopo. LexicalCast presenta alcuni vantaggi in quanto garantisce che la trasformazione sia completa. Usa stringstreams internamente.

Vorrei esaminare la C ++ String Toolkit Libary . Ho appena pubblicato una risposta simile altrove. L'ho trovato molto veloce e affidabile.

#include <strtk.hpp>

double pi = M_PI;
std::string pi_as_string  = strtk::type_to_string<double>( 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 piccola, ciò influirebbe sulla tua produzione.

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

Potresti voler leggere i miei precedenti post su SO. (Versione macro con un oggetto ostringstream 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 hai eseguito il loop per farlo due volte ...)

(L'ho anche spostato tramite vsnprintf (). Ma questo mi costa un po 'di controllo del tipo. Yelp se vuoi il codice ...)

Dai un'occhiata sprintf()e famiglia.

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

/* gcvt example */
#include <stdio.h>
#include <stdlib.h>

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

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 <iostream>   
#include <string>  

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

  return 0;
}

eseguilo tu stesso: http://ideone.com/7ejfaU Anche
questi sono 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 qualsiasi cosa usando questa funzione:

template<class T = std::string, class U>
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<double>("2.5");