Comment convertir un double en chaîne en C ++?

J'ai besoin de stocker un double sous forme de chaîne. Je sais que je peux l'utiliser printfsi je voulais l'afficher, mais je veux juste le stocker dans une variable de chaîne afin que je puisse le stocker dans une carte plus tard (comme valeur , pas comme clé ).

La manière boost (tm) :

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

La manière standard C ++ :

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

Remarque : n'oubliez pas#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);

La méthode Standard C ++ 11 (si vous ne vous souciez pas du format de sortie):

#include <string>

auto str = std::to_string(42.5); 

to_stringest une nouvelle fonction de bibliothèque introduite dans N1803 (r0), N1982 (r1) et N2408 (r2) " Simple Numeric Access ". Il existe également la stodfonction pour effectuer l'opération inverse.

Si vous souhaitez avoir un format de sortie différent de celui "%f", utilisez les méthodes snprintfou ostringstreamcomme illustré dans d'autres réponses.

Si vous utilisez C ++, évitez sprintf. C'est un-C ++ y et a plusieurs problèmes. Stringstreams est la méthode de choix, de préférence encapsulée comme dans Boost.LexicalCast qui peut être fait assez facilement:

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

Usage:

string s = to_string(42.5);

Vous pouvez utiliser std :: to_string en C ++ 11

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

sprintfc'est bien, mais en C ++, la meilleure façon, la plus sûre et aussi légèrement plus lente de faire la conversion est avec stringstream:

#include <sstream>
#include <string>

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

Vous pouvez également utiliser Boost.LexicalCast :

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

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

Dans les deux cas, strdevrait être "453.23"après. LexicalCast présente certains avantages en ce sens qu'il garantit que la transformation est complète. Il utilise stringstreams en interne.

Je regarderais la bibliothèque C ++ String Toolkit . Je viens de publier une réponse similaire ailleurs. Je l'ai trouvé très rapide et fiable.

#include <strtk.hpp>

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

Herb Sutter a un excellent article sur le formatage des chaînes . Je recommande de le lire. Je l'ai déjà lié sur SO.

Le problème avec lexical_cast est l'incapacité de définir la précision. Normalement, si vous convertissez un double en chaîne, c'est parce que vous souhaitez l'imprimer. Si la précision est trop ou trop faible, cela affectera votre sortie.

Vous pouvez également utiliser stringstream .

Heh, je viens d'écrire ceci (sans rapport avec cette question):

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

/* rest of the code */

Vous voudrez peut-être lire mon article précédent sur SO. (Version macro avec un objet ostringstream temporaire.)

Pour mémoire: dans mon propre code, je préfère snprintf (). Avec un tableau char sur la pile locale, ce n'est pas si inefficace. (Eh bien, peut-être si vous avez dépassé la taille du tableau et que vous avez fait une boucle pour le faire deux fois ...)

(Je l'ai également enveloppé via vsnprintf (). Mais cela me coûte une vérification de type. Yelp si vous voulez le code ...)

Jetez un oeil à sprintf()et famille.

Normalement, pour ces opérations, vous devez utiliser les fonctions ecvt, fcvt ou 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   

En tant que fonction:

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

Vous pouvez essayer un style plus compact:

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

Utilisez to_string().
exemple :

#include <iostream>   
#include <string>  

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

  return 0;
}

lancez-le vous-même: http://ideone.com/7ejfaU
Ils sont également disponibles:

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

Vous pouvez convertir n'importe quoi en n'importe quoi en utilisant cette fonction:

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

utilisation:

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