Como converter um duplo em uma string em C ++?

Eu preciso armazenar um duplo como uma string. Sei que posso usá-lo printfse quiser exibi-lo, mas só quero armazená-lo em uma variável de cadeia para que possa armazená-lo em um mapa mais tarde (como o valor , não a chave ).

A maneira boost (tm) :

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

A maneira C ++ padrão :

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

Nota : Não esqueça#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);

A maneira C ++ 11 padrão (se você não se importa com o formato de saída):

#include <string>

auto str = std::to_string(42.5); 

to_stringé uma nova função de biblioteca introduzida no " Acesso Numérico Simples " N1803 (r0), N1982 (r1) e N2408 (r2) . Também há a função de executar a operação reversa.stod

Se você deseja ter um formato de saída diferente "%f", use os métodos snprintfou ostringstreamconforme ilustrado em outras respostas.

Se você usa C ++, evite sprintf. É un-C ++ y e tem vários problemas. Os fluxos de string são o método de escolha, de preferência encapsulado como no Boost.LexicalCast, que pode ser feito com bastante facilidade:

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

Uso:

string s = to_string(42.5);

Você pode usar std :: to_string no C ++ 11

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

sprintfestá bem, mas em C ++, a maneira melhor, mais segura e também um pouco mais lenta de fazer a conversão é com stringstream:

#include <sstream>
#include <string>

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

Você também pode usar o Boost.LexicalCast :

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

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

Nos dois casos, strdeve ser "453.23"posterior. O LexicalCast tem algumas vantagens, pois garante que a transformação está completa. Ele usa stringstreams internamente.

Gostaria de olhar para o C ++ String Toolkit Libary . Apenas postou uma resposta semelhante em outro lugar. Eu achei muito rápido e confiável.

#include <strtk.hpp>

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

Herb Sutter tem um excelente artigo sobre formatação de strings . Eu recomendo a leitura. Eu já o vinculei antes no SO.

O problema com lexical_cast é a incapacidade de definir precisão. Normalmente, se você estiver convertendo um duplo em uma sequência, é porque deseja imprimi-la. Se a precisão for muito ou pouco, isso afetaria sua saída.

Você também pode usar stringstream .

Heh, acabei de escrever isso (não relacionado a esta pergunta):

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

/* rest of the code */

Você pode ler minha postagem anterior no SO. (Versão em macro com um objeto ostringstream temporário.)

Para constar: No meu próprio código, sou a favor de snprintf (). Com uma matriz de caracteres na pilha local, não é tão ineficiente. (Bem, talvez se você excedeu o tamanho da matriz e fez um loop para fazer isso duas vezes ...)

(Também o envolvi via vsnprintf (). Mas isso me custa uma verificação de tipo. Yelp se você quiser o código ...)

Dê uma olhada sprintf()e família.

Normalmente, para essas operações, é necessário usar as funções ecvt, fcvt ou 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 uma função:

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

Você pode tentar um estilo mais 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(); 

Use to_string().
exemplo:

#include <iostream>   
#include <string>  

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

  return 0;
}

execute você mesmo: http://ideone.com/7ejfaU
Estes também estão disponíveis:

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

Você pode converter qualquer coisa para qualquer coisa usando esta função:

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