¿Cómo convierto un doble en una cadena en C ++?

Necesito almacenar un doble como una cadena. Sé que puedo usar printfsi quisiera mostrarlo, pero solo quiero almacenarlo en una variable de cadena para poder almacenarlo en un mapa más tarde (como el valor , no la clave ).

La forma de impulso (tm) :

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

La forma estándar de C ++ :

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

Nota : no olvides#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);

La forma estándar de C ++ 11 (si no le importa el formato de salida):

#include <string>

auto str = std::to_string(42.5); 

to_stringes una nueva función de biblioteca introducida en N1803 (r0), N1982 (r1) y N2408 (r2) " Acceso numérico simple ". También están losstod función para realizar la operación inversa.

Si desea tener un formato de salida diferente que "%f", use los métodos snprintfo ostringstreamcomo se ilustra en otras respuestas.

Si usa C ++, evítelo sprintf. No es C ++ y tiene varios problemas. Los Stringstreams son el método de elección, preferiblemente encapsulado como en Boost.LexicalCast que se puede hacer con bastante facilidad:

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

Uso:

string s = to_string(42.5);

Puede usar std :: to_string en C ++ 11

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

sprintfestá bien, pero en C ++, la forma mejor, más segura y también un poco más lenta de hacer la conversión es con stringstream:

#include <sstream>
#include <string>

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

También puedes usar Boost.LexicalCast :

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

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

En ambos casos, strdebe ser "453.23"posterior. LexicalCast tiene algunas ventajas, ya que garantiza que la transformación se complete. Utiliza stringstreams internamente.

Me gustaría ver el C ++ String Toolkit Libary . Acabo de publicar una respuesta similar en otro lugar. Lo he encontrado muy rápido y confiable.

#include <strtk.hpp>

double pi = M_PI;
std::string pi_as_string  = strtk::type_to_string<double>( pi );

Herb Sutter tiene un excelente artículo sobre el formato de cadenas . Recomiendo leerlo Lo he vinculado antes en SO.

El problema con lexical_cast es la incapacidad para definir la precisión. Normalmente, si está convirtiendo un doble en una cadena, es porque desea imprimirlo. Si la precisión es demasiado o muy poco, afectaría su salida.

También puedes usar stringstream .

Je, acabo de escribir esto (sin relación con esta pregunta):

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

/* rest of the code */

Es posible que desee leer mi publicación anterior en SO. (Versión macro'ed con un objeto ostringstream temporal).

Para el registro: en mi propio código, estoy a favor de snprintf (). Con una matriz de caracteres en la pila local, no es tan ineficiente. (Bueno, tal vez si superaste el tamaño de la matriz y lo hiciste dos veces ...)

(También lo envié a través de vsnprintf (). Pero eso me cuesta un poco de verificación de tipos. Yelp si quieres el código ...)

Echa un vistazo sprintf()y familia.

Normalmente para estas operaciones, debe usar las funciones 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   

Como una función:

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

Podrías probar un estilo más compacto:

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

Uso to_string().
ejemplo:

#include <iostream>   
#include <string>  

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

  return 0;
}

ejecútelo usted mismo: http://ideone.com/7ejfaU
Estos también están disponibles:

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

Puedes convertir cualquier cosa a cualquier cosa usando esta función:

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

uso:

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