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

Question

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

Answer 1

El impulso (tm) manera:

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

El estándar de C++ manera:

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

Nota: No se olvide #include <sstream>

Answer 2

Eche un vistazo a sprintf() y su familia.

Answer 3

También podría usar stringstream.

Answer 4

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

Si usa C++, evite sprintf. Es un-C++ y tiene varios problemas. Stringstreams son el método de elección, preferentemente 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 6

Je, me acaba 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 7

sprintf está 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 puede utilizar 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, debe ser str"453.23" después. LexicalCast tiene algunas ventajas en el sentido de que asegura que la transformación se complete. Utiliza stringstream s internamente.

Answer 8

Herb Sutter tiene un excelente article on string formatting . Recomiendo leerlo Tengo linked it before en SO.

Answer 9

You may want to read my prior posting on SO. (Macro'ed version with a temporary ostringstream object.)

Para el registro: En mi propio código, que favorecen snprintf(). Con una matriz de caracteres en la pila local, no es tan ineficiente. (Bueno, tal vez si excedió el tamaño de la matriz y realizó un bucle para hacerlo dos veces ...)

(También lo envolví mediante vsnprintf(). Pero eso me cuesta algo de comprobación. Yelp si quiere el código ...)

Answer 10

El problema con lexical_cast es la imposibilidad de 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 salida.

Answer 11

El estándar de C++ 11 manera (si no se preocupan por el formato de salida):

#include <string> 

auto str = std::to_string(42.5); 

to_string es una nueva función introducida en la biblioteca N1803 (R0), N1982 (r1) y N2408 (r2) "Simple Numeric Access". También existe la función stod para realizar la operación inversa.

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

Answer 12

usted podría intentar 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 13

me gustaría ver en 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); 

Answer 14

Normaly para estas operaciones se tienen que utilizar los ECVT, fcvt o gcvt Funciones:

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

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

plazo usted mismo: http://ideone.com/7ejfaU
Estos están disponibles, así:

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 16

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

Answer 17

Puede utilizar std::to_string en C++ 11

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