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

Question

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

Answer 1

La méthode boost (tm) :

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

La méthode Standard C ++ :

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

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

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_string est une nouvelle fonction de bibliothèque introduite dans N1803 (r0), N1982 (r1) et N2408 (r2) &"; Simple Accès numérique &>; Il existe également la fonction stod permettant d'effectuer l'opération inverse.

Si vous souhaitez utiliser un format de sortie différent de "%f", utilisez les méthodes snprintf ou ostringstream comme indiqué dans les autres réponses.

Answer 4

Si vous utilisez C ++, évitez sprintf. C'est un-C ++ y et a plusieurs problèmes. Les chaînes de caractères constituent la méthode de choix, de préférence encapsulée comme suit: 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();
}

Utilisation:

string s = to_string(42.5);

Answer 5

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

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

Answer 6

sprintf est correct, mais en C ++, le moyen le plus efficace, le plus sûr et le plus lent pour effectuer 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, str doit être "453.23" ensuite. LexicalCast présente certains avantages en ce sens qu'il assure la transformation complète. Il utilise <=> s en interne.

Answer 7

Je regarderais le Libary de la boîte à outils pour les chaînes C ++ . Vient de poster 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 );

Answer 8

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

Answer 9

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 voulez l'imprimer. Si la précision est trop grande ou trop faible, cela affectera votre sortie.

Answer 10

Vous pouvez également utiliser stringstream .

Answer 11

Hé, 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 */

Answer 12

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

Pour mémoire: dans mon propre code, je privilégie snprintf (). Avec un tableau de caractères sur la pile locale, ce n'est pas si inefficace. (Eh bien, peut-être que si vous avez dépassé la taille du tableau et que vous avez bouclé deux fois ...)

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

Answer 13

Jetez un coup d'œil sur sprintf() et sa famille.

Answer 14

Normalement, pour cette opération, 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);
}

Answer 15

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

Answer 16

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

exécutez-le vous-même: http://ideone.com/7ejfaU
Ceux-ci 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);

Answer 17

Vous pouvez convertir 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");