Wie kann ich ein Doppel in einen String in C ++ konvertieren?

Question

Ich brauche eine Doppel als Zeichenfolge zu speichern. Ich weiß, ich printf verwenden kann, wenn ich es angezeigt werden will, aber ich will es nur in einer String-Variablen speichern, so dass ich es in einer Karte später speichern kann (als Wert , nicht die Taste ).

Answer 1

Die Boost (tm) Art und Weise:

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

Die Standard C ++ Art und Weise:

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

Hinweis : Vergessen Sie nicht #include <sstream>

Answer 2

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

Answer 3

Die Standard C ++ 11 Art und Weise (wenn Sie über das Ausgabeformat nicht kümmern):

#include <string>

auto str = std::to_string(42.5); 

to_string ist eine neue Bibliotheksfunktion in N1803 (r0), N1982 (R1) und N2408 (r2)" Einfache Numerische Zugang “. Darüber hinaus gibt es die stod Funktion den umgekehrten Vorgang durchzuführen.

Wenn Sie wollen ein anderes Ausgabeformat als "%f" haben, verwenden Sie die snprintf oder ostringstream Methoden dargestellt, wie in anderen Antworten.

Answer 4

Wenn Sie C ++ verwenden, vermeiden sprintf. Es ist un-C ++ y und mehrere Probleme hat. Stringstreams sind das Mittel der Wahl, vorzugsweise wie in Boost.LexicalCast , die ganz leicht getan werden kann:

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

Verbrauch:

string s = to_string(42.5);

Answer 5

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

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

Answer 6

sprintf ist in Ordnung, aber in C ++, desto besser, sicherer und auch etwas langsamem Weg, um die Umwandlung zu tun, ist mit 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 verwenden Boost.LexicalCast :

#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 str sollte danach "453.23" werden. LexicalCast hat einige Vorteile, da sie gewährleistet die Umwandlung abgeschlossen ist. Es verwendet stringstreams intern.

Answer 7

ich auf dem C ++ String Toolkit Libary aussehen würde. Gerade gepostet anderswo eine ähnliche Antwort. 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 );

Answer 8

Herb Sutter hat eine ausgezeichnete Artikel auf Zeichenfolge Formatierung rel="nofollow. Ich empfehle es zu lesen. Ich habe verknüpft es vor auf SO.

Answer 9

Das Problem mit lexical_cast ist die Unfähigkeit, präzise zu definieren. Normalerweise, wenn Sie eine Doppel in eine Zeichenfolge konvertieren, ist es, weil Sie es heraus drucken möchten. Wenn die Genauigkeit zu viel oder zu wenig ist, wäre es die Ausgabe beeinflussen.

Answer 10

Sie können auch benutzen string .

Answer 11

Heh, ich schreibe gerade diese (unabhängig von dieser Frage):

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

/* rest of the code */

Answer 12

Möglicherweise möchten Sie meine vorherige Aufgabe auf SO lesen. (Macro'ed Version mit einem temporären Ostringstream-Objekt.)

Für das Protokoll: In meinem eigenen Code, ich bevorzuge snprintf (). Mit einem char-Array auf dem lokalen Stapel, ist es nicht so ineffizient. (Na ja, vielleicht überschritten, wenn Sie die Größe des Arrays und geschlungen es zweimal zu tun ...)

(Ich habe wickelte es auch über vsnprintf (). Aber das kostet mich eine Art Überprüfung. Yelp wenn Sie den Code wollen ...)

Answer 13

Werfen Sie einen Blick auf sprintf() und Familie.

Answer 14

Normaly für diese Operationen Sie die ecvt, fcvt oder gcvt Funktionen 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 Funktion:

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

Answer 15

Sie könnten versuchen, eine kompaktere Stil:

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 16

Mit 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;
}

run it yourself: http://ideone.com/7ejfaU
Diese sind auch:

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 17

Sie können eine beliebige Sache zu etwas konvertieren mit dieser Funktion:

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

Nutzung:

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