¿Cómo puedo convertir de un doble en una cadena de caracteres en C++?

Question

Necesito almacenar un doble como una cadena.Sé que puedo usar printf si yo quería mostrarlo, pero sólo quiero almacenar en una variable de cadena, de modo que puedo almacenar en un mapa más tarde (como la valor, no la clave).

Answer 1

La forma boost (tm) :

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

La forma C ++ estándar :

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

Nota : No olvides #include <sstream>

Answer 2

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

Answer 3

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

#include <string>

auto str = std::to_string(42.5); 

to_string es una nueva función de biblioteca introducida en N1803 (r0), N1982 (r1) y N2408 (r2) " Simple Acceso numérico & Quot ;. También existe la función stod para realizar la operación inversa.

Si desea tener un formato de salida diferente a "%f", use los métodos snprintf o ostringstream como se ilustra en otras respuestas.

Answer 4

Si usa C ++, evite sprintf. Es un-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);

Answer 5

Puede usar std :: to_string en C ++ 11

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

Answer 6

sprintf está bien, pero en C ++, la forma mejor, más segura y también un poco más lenta de realizar 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 puede 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, str debería ser "453.23" después. LexicalCast tiene algunas ventajas porque garantiza que la transformación se complete. Utiliza <=> s internamente.

Answer 7

Vería la 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 );

Answer 8

Herb Sutter tiene un excelente artículo sobre formato de cadenas . Recomiendo leerlo lo vinculé antes en SO.

Answer 9

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 poca, afectaría su producción.

Answer 10

También puede usar stringstream .

Answer 11

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

Answer 12

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 para hacerlo ...)

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

Answer 13

Echa un vistazo a sprintf() y la familia.

Answer 14

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

Answer 15

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

Answer 16

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

Answer 17

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