web-dev-qa-db-fra.com

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 utiliser printf si je voulais l’afficher, mais je veux juste le stocker dans une variable chaîne pour pouvoir le stocker dans une carte ultérieurement (comme valeur, pas le clé).

c++stringdouble
159
Bill the Lizard

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

Note: N'oubliez pas #include <sstream>

176
Johannes Schaub - litb
// 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);
182
Adam Rosenfield

La manière 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 N18 (r0), N1982 (r1) et N2408 = (r2) " Accès numérique simple ". Il existe également la fonction stod pour 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 illustré dans d'autres réponses.

114
kennytm

Si vous utilisez C++, évitez sprintf. C'est un-C++ y et a plusieurs problèmes. Les chaînes de caractères sont la méthode de choix, de préférence encapsulée comme dans Boost.LexicalCast ce 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);
24
Konrad Rudolph

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

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

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 devrait être "453.23" par la suite. LexicalCast présente certains avantages en ce sens qu'il garantit la transformation complète. Il utilise stringstreams en interne.

10
coppro

Je regarderais le C++ String Toolkit Libary . 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 );
10
DannyK

Herb Sutter a un excellent article sur le formatage de chaîne . Je recommande de le lire. J'ai lié auparavant sur SO.

7
Fred Larson

Le problème avec lexical_cast est l'impossibilité 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.

6
Foxhunter

Vous pouvez également utiliser stringstream .

4
Firas Assaad

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 */
4
Vinko Vrsalovic

Regardez sprintf() et sa famille.

2
Darron

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);
}
2
Ingo

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

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. (Et bien, peut-être que si vous avez dépassé la taille du tableau et que vous avez bouclé pour le faire 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 ...)

2
Mr.Ree

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();
0
Alexis Sánchez Tello

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");
0
Sam Mokari

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/7ejfa
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);
0
Breeze