Wie konvertiere ich ein Double in einen String in C ++?

Ich muss ein Double als String speichern. Ich weiß, dass ich es verwenden kann, printfwenn ich es anzeigen möchte, aber ich möchte es nur in einer Zeichenfolgenvariablen speichern, damit ich es später in einer Karte speichern kann (als Wert , nicht als Schlüssel ).

Der Boost (tm) Weg:

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

Der Standard C ++ Weg:

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

Hinweis : Vergessen Sie nicht#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);

Der Standard C ++ 11 Weg (wenn Sie sich nicht für das Ausgabeformat interessieren):

#include <string>

auto str = std::to_string(42.5); 

to_stringist eine neue Bibliotheksfunktion, die in N1803 (r0), N1982 (r1) und N2408 (r2) " Simple Numeric Access " eingeführt wurde. Es gibt auch die stodFunktion, den Rückwärtsgang durchzuführen.

Wenn Sie ein anderes Ausgabeformat als möchten "%f", verwenden Sie die Methoden snprintfoder ostringstream, wie in anderen Antworten dargestellt.

Wenn Sie C ++ verwenden, vermeiden Sie sprintf. Es ist un-C ++ y und hat mehrere Probleme. Stringstreams sind die Methode der Wahl, vorzugsweise wie in Boost.LexicalCast gekapselt , was ganz einfach möglich ist:

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

Verwendung:

string s = to_string(42.5);

Sie können std :: to_string in C ++ 11 verwenden

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

sprintfist in Ordnung, aber in C ++ ist die bessere, sicherere und auch etwas langsamere Art der Konvertierung stringstream:

#include <sstream>
#include <string>

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

Sie können auch Boost.LexicalCast verwenden :

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

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

In beiden Fällen strsollte "453.23"danach sein. LexicalCast bietet einige Vorteile, da es sicherstellt, dass die Transformation abgeschlossen ist. Es verwendet stringstreams intern.

Ich würde mir die C ++ String Toolkit Libary ansehen . Habe gerade eine ähnliche Antwort an anderer Stelle gepostet. Ich habe es sehr schnell und zuverlässig gefunden.

#include <strtk.hpp>

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

Herb Sutter hat einen ausgezeichneten Artikel über die Formatierung von Strings . Ich empfehle es zu lesen. Ich habe es schon einmal auf SO verlinkt .

Das Problem mit lexical_cast ist die Unfähigkeit, die Genauigkeit zu definieren. Wenn Sie ein Double in eine Zeichenfolge konvertieren, möchten Sie dies normalerweise ausdrucken. Wenn die Genauigkeit zu hoch oder zu gering ist, wirkt sich dies auf Ihre Ausgabe aus.

Sie können auch stringstream verwenden .

Heh, ich habe das gerade geschrieben (ohne Bezug zu dieser Frage):

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

/* rest of the code */

Vielleicht möchten Sie meinen vorherigen Beitrag auf SO lesen. (Makroversion mit einem temporären Ostringstream-Objekt.)

Für die Aufzeichnung: In meinem eigenen Code bevorzuge ich snprintf (). Mit einem char-Array auf dem lokalen Stapel ist es nicht so ineffizient. (Nun, vielleicht, wenn Sie die Arraygröße überschritten und eine Schleife durchgeführt haben, um dies zweimal zu tun ...)

(Ich habe es auch über vsnprintf () verpackt. Aber das kostet mich eine Typprüfung. Yelp, wenn Sie den Code wollen ...)

Schauen Sie sich an sprintf()und Familie.

Normalerweise müssen Sie für diese Operationen die Funktionen ecvt, fcvt oder gcvt verwenden:

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

Als eine Funktion:

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

Sie könnten einen kompakteren Stil ausprobieren:

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

Verwenden Sie to_string().
Beispiel:

#include <iostream>   
#include <string>  

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

  return 0;
}

Führen Sie es selbst aus: http://ideone.com/7ejfaU
Diese sind ebenfalls verfügbar:

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

Mit dieser Funktion können Sie alles in alles konvertieren:

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

Verwendung :

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