Como faço para converter um double em um string em C ++?
Pergunta
Eu preciso armazenar uma dupla como uma string. Eu sei que eu posso usar printf
se eu queria exibi-lo, mas eu só quero armazená-lo em uma variável de seqüência para que eu possa armazená-lo em um mapa mais tarde (como o valor , e não o tecla ).
Solução
O boost (tm) maneira:
std::string str = boost::lexical_cast<std::string>(dbl);
O C ++ padrão maneira:
std::ostringstream strs;
strs << dbl;
std::string str = strs.str();
Nota ??strong>: Não se esqueça #include <sstream>
Outras dicas
// 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);
O padrão C ++ 11 maneira (se você não se preocupam com o formato de saída):
#include <string>
auto str = std::to_string(42.5);
to_string
é uma nova função de biblioteca introduzido em N1803 (R0), N1982 (R1) e N2408 (r2)" simples numérico de Acesso ". Há também a função stod
para realizar a operação inversa.
Se você quiser ter um formato de saída diferente do que "%f"
, utilize os métodos snprintf
ou ostringstream
como ilustrado em outras respostas.
Se você usar C ++, evite sprintf
. É de un-C ++ y e tem vários problemas. Stringstreams são o método de escolha, de preferência encapsulado como em 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 em C ++ 11
double d = 3.0;
std::string str = std::to_string(d);
sprintf
é bom, mas em C ++, a melhor maneira, mais seguro, e também um pouco mais lento 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 Boost.LexicalCast :
#include <boost/lexical_cast.hpp>
#include <string>
// In some function:
double d = 453.23;
std::string str = boost::lexical_cast<string>(d);
Em ambos os casos, str
deve ser "453.23"
depois. LexicalCast tem algumas vantagens na medida em que assegura a transformação é completa. Ele usa stringstream
s internamente.
Eu olhava para o C ++ Cordas Toolkit Libary . Só postou uma resposta semelhante em outro lugar. Descobri que é 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 uma excelente href="http://www.gotw.ca/publications/mill19.htm" artigo na corda formatação . Eu recomendo a leitura. Eu ligada antes no SO.
O problema com lexical_cast é a incapacidade de definir precisão. Normalmente, se você está convertendo um duplo para uma cadeia, é porque você quer imprimi-lo. Se a precisão é muito ou pouco, isso afetaria sua saída.
Você também pode usar stringstream .
Heh, eu só escrevi isso (não relacionada 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 */
Para o registro: No meu próprio código, sou a favor snprintf (). Com uma matriz de char na pilha local, que não é tão ineficiente. (Bem, talvez se você excedeu o tamanho da matriz e loop para fazê-lo duas vezes ...)
(Eu também envolveu-o via vsnprintf (). Mas que custa-me algum tipo de verificação. Yelp se quiser que o código ...)
Dê uma olhada sprintf()
e familiar.
Normaly para estas operações você tem que usar os ecvt, fcvt ou gcvt Funções:
/* 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 Função:
void double_to_char(double f,char * buffer){
gcvt(f,10,buffer);
}
Você poderia 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;
}
executá-lo a si 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 a 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");