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é).
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>
// 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 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.
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);
Vous pouvez utiliser std :: to_string en C++ 11
double d = 3.0;
std::string str = std::to_string(d);
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 stringstream
s en interne.
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 );
Herb Sutter a un excellent article sur le formatage de chaîne . Je recommande de le lire. J'ai lié auparavant sur SO.
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.
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 */
Regardez sprintf()
et sa 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);
}
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 ...)
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();
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");
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);