Come faccio a convertire un doppio in una stringa in C ++?

Question

Devo memorizzare un doppio come stringa. So che posso usare printf se volessi visualizzarlo, ma voglio solo memorizzarlo in una variabile stringa in modo da poterlo archiviare in una mappa in seguito (come valore , non il tasto ).

Answer 1

Il modo boost (tm) :

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

Il modo C ++ standard :

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

Nota : non dimenticare #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

Il modo Standard C ++ 11 (se non ti interessa il formato di output):

#include <string>

auto str = std::to_string(42.5); 

to_string è una nuova funzione di libreria introdotta in N1803 (r0), N1982 (r1) e N2408 (r2) " Semplice Accesso numerico & Quot ;. Ci sono anche le funzioni stod per eseguire l'operazione inversa.

Se si desidera avere un formato di output diverso da "%f", utilizzare i metodi snprintf o ostringstream come illustrato in altre risposte.

Answer 4

Se si utilizza C ++, evitare sprintf. È un-C ++ y e ha diversi problemi. I flussi di stringhe sono il metodo di scelta, preferibilmente incapsulato come in Boost.LexicalCast che può essere fatto abbastanza facilmente:

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

Utilizzo:

string s = to_string(42.5);

Answer 5

Puoi utilizzare std :: to_string in C ++ 11

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

Answer 6

sprintf va bene, ma in C ++ il modo migliore, più sicuro e anche leggermente più lento di fare la conversione è con stringstream:

#include <sstream>
#include <string>

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

Puoi anche utilizzare 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 entrambi i casi, str dovrebbe essere "453.23" in seguito. LexicalCast presenta alcuni vantaggi in quanto garantisce che la trasformazione sia completa. Utilizza <=> internamente.

Answer 7

Vorrei esaminare la C ++ String Toolkit Libary . Ho appena pubblicato una risposta simile altrove. L'ho trovato molto veloce e affidabile.

#include <strtk.hpp>

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

Answer 8

Herb Sutter ha un eccellente articolo sulla formattazione delle stringhe . Consiglio di leggerlo. L'ho collegato prima su SO.

Answer 9

Il problema con lexical_cast è l'incapacità di definire la precisione. Normalmente se stai convertendo un doppio in una stringa, è perché vuoi stamparlo. Se la precisione è troppo o troppo piccola, ciò influenzerebbe il tuo output.

Answer 10

Puoi anche utilizzare stringstream .

Answer 11

Heh, ho appena scritto questo (non correlato a questa domanda):

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

/* rest of the code */

Answer 12

Potresti voler leggere i miei precedenti post su SO. (Versione macro con un oggetto ostringstream temporaneo.)

Per la cronaca: nel mio codice, preferisco snprintf (). Con un array di caratteri nello stack locale, non è così inefficiente. (Beh, forse se hai superato la dimensione dell'array e hai eseguito il loop per farlo due volte ...)

(L'ho anche spostato tramite vsnprintf (). Ma questo mi costa un po 'di controllo del tipo. Yelp se vuoi il codice ...)

Answer 13

Dai un'occhiata a sprintf() e famiglia.

Answer 14

Normalmente per queste operazioni devi usare le funzioni ecvt, fcvt o 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   

Come funzione:

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

Answer 15

Potresti provare uno stile più compatto:

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

Usa to_string().
esempio:

#include <iostream>   
#include <string>  

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

  return 0;
}

eseguilo da solo: http://ideone.com/7ejfaU
Sono disponibili anche questi:

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

Puoi convertire qualsiasi cosa in qualsiasi cosa usando questa funzione:

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

utilizzo:

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