Jak przekonwertować double na ciąg w C ++?

Muszę przechowywać podwójną jako ciąg. Wiem, że mogę go użyć, printfjeśli chcę go wyświetlić, ale chcę go po prostu zapisać w zmiennej ciągu, aby móc później zapisać go na mapie (jako wartość , a nie klucz ).

Sposób wzmocnienia (tm) :

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

Przez standard C ++ sposób:

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

Uwaga : nie zapomnij#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);

Standardowa C ++ 11 sposób (jeśli nie dbają o format wyjściowy):

#include <string>

auto str = std::to_string(42.5); 

to_stringto nowa funkcja biblioteczna wprowadzona w N1803 (r0), N1982 (r1) i N2408 (r2) „ Prosty dostęp numeryczny ”. Istnieje również stodfunkcja wykonywania operacji odwrotnej.

Jeśli chcesz mieć inny format wyjściowy niż "%f", użyj metod snprintflub ostringstream, jak pokazano w innych odpowiedziach.

Jeśli używasz C ++, unikaj sprintf. Nie jest napisane w C ++ i ma kilka problemów. Stringstreams to metoda z wyboru, najlepiej hermetyzowana, jak w Boost.LexicalCast, co można zrobić dość łatwo:

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

Stosowanie:

string s = to_string(42.5);

Możesz użyć std :: to_string w C ++ 11

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

sprintfjest w porządku, ale w C ++ lepszym, bezpieczniejszym i nieco wolniejszym sposobem konwersji jest stringstream:

#include <sstream>
#include <string>

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

Możesz także użyć Boost.LexicalCast :

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

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

W obu przypadkach strpowinno być "453.23"później. LexicalCast ma pewne zalety, ponieważ zapewnia całkowitą transformację. Używa stringstreams wewnętrznie.

Spojrzałbym na C ++ String Toolkit Libary . Właśnie opublikowałem podobną odpowiedź w innym miejscu. Okazało się, że jest bardzo szybki i niezawodny.

#include <strtk.hpp>

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

Herb Sutter ma doskonały artykuł na temat formatowania ciągów . Polecam ją przeczytać. Mam związane ją przed na SO.

Problem z lexical_cast polega na niemożności zdefiniowania precyzji. Zwykle, jeśli konwertujesz double na ciąg, dzieje się tak, ponieważ chcesz go wydrukować. Jeśli precyzja jest za duża lub za mała, wpłynie to na wynik.

Możesz także użyć stringstream .

Heh, właśnie napisałem to (niezwiązane z tym pytaniem):

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

/* rest of the code */

Możesz przeczytać mój wcześniejszy post na SO. (Wersja makro z tymczasowym obiektem ostringstream.)

Dla przypomnienia: w moim własnym kodzie preferuję snprintf (). Z tablicą char na lokalnym stosie nie jest to takie nieefektywne. (Cóż, może jeśli przekroczyłeś rozmiar tablicy i zapętlono, aby zrobić to dwukrotnie ...)

(Zapakowałem to również za pomocą vsnprintf (). Ale to kosztuje mnie trochę sprawdzenia typu. Yelp, jeśli chcesz kod ...)

Przyjrzyj się sprintf()i rodzinie.

Normalnie dla tych operacji musisz użyć funkcji ecvt, fcvt lub 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   

Jako funkcja:

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

Możesz wypróbować bardziej kompaktowy styl:

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

Użyj to_string().
przykład:

#include <iostream>   
#include <string>  

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

  return 0;
}

uruchom go samodzielnie: http://ideone.com/7ejfaU
Te są również dostępne:

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

Możesz przekonwertować dowolną rzecz na cokolwiek za pomocą tej funkcji:

template<class T = std::string, class U>
T to(U a) {
    std::stringstream ss;
    T ret;
    ss << a;
    ss >> ret;
    return ret;
};

stosowanie :

std::string str = to(2.5);
double d = to<double>("2.5");