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

funciones de cadenas de caracteres 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 que pueda almacenarlo en un mapa más tarde (como el valor , no la clave ).

Answer 1

Eche un vistazo a sprintf() y familia.

Answer 2

El problema con lexical_cast es la incapacidad de definir 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 3

Heh, 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 4

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

Answer 5

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_string es una nueva función de biblioteca introducida en N1803 (r0), N1982 (r1) y N2408 (r2) " Simple Numeric Access ". También hay 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 6

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 olvide #include <sstream>

Answer 7

Me gustaría ver la Librería de C ++ String Toolkit . 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

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 9

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 10

Puede convertir cualquier cosa en 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 11

Puede usar to_string en C ++ 11

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

Answer 12

Si usa C ++, evite sprintf . Es un-C ++ y tiene varios problemas. Stringstreams es 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 13

También podría usar stringstream .

Answer 14

Use 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 están disponibles también:

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 15

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

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

(También lo he envuelto a través de vsnprintf (). Pero eso me cuesta algo de chequeo. Yelp si quieres el código ...)

Answer 16

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 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, str debe ser "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 17

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