La conversion de `double` de `string`

Je suis la mise en œuvre de cette:

double x;
ostringstream x_convert;
x_convert << x;
string x_str = x_convert.str();

Il semble un peu superflu. Est-il un moyen plus élégant?

en double? stackoverflow.com/questions/7228438/...
Ne le pense pas
Ne pas identifier cette question [C]. ostringstream, .str();, sont [C++] seulement, pas [C]
Vous pourriez juste envelopper le tout dans une fonction, donc vous n'avez plus à taper. C++11 est fait pour vous, std::to_string(), comme tout le monde l'a souligné. Le problème est le manque de contrôle sur la façon dont la chaîne ressemble.

InformationsquelleAutor Plamen | 2013-10-30

c++double string type-conversion

10

Êtes-vous à l'aide de C++11? Si donc, il y a:
```
auto x_str = std::to_string(x);
```
InformationsquelleAutor Barry
4

std::to_string:
```
std::string x_str = std::to_string(x);
```
InformationsquelleAutor 0x499602D2
3

Ce que vous avez est le la plus sûre méthode (avant C++11).

Sinon, vous pouvez donc quelque chose comme:
```
double value = SOME_VALUE;
char buffer[100] = {};
sprintf(buffer, "%f", value);
std::string s = buffer;
```
Qui est fonctionnellement équivalent à ce que std::to_string n'. Vous devez faire attention à avoir assez d'espace alloué pour buffer, et (comme vous pouvez le voir), vous êtes toujours écrit sur les 4 lignes de code pour faire cette conversion, de sorte qu'il n'est pas plus (ni moins) élégant que les autres méthodes.

Si vous êtes coincé dans le pré-C++11, vous pouvez mettre en place votre propre to_string en faisant quelque chose comme:
```
template<typename T>
std::string to_string(T t)
{
    std::ostringstream oss;
    oss << t;
    return oss.str();
}
```
Qui va travailler pour n'importe quel type qui a déjà une surcharge pour std::ostream& operator<<(std::ostream&, T&).
- Euh, il n'y a rien dans cette utilisation de sprintf qui n'est pas "sûr"; il fonctionne très bien.
- Comme je l'ai alloué une mémoire tampon qui est sensiblement plus grand que une précision en virgule flottante peuvent être dans ce cas, vous avez raison. Si je change la taille de buffer à 10, par exemple, il n'est plus le cas.
- Oui, si le code est différent, le résultat pourrait être différent. Mais il ne l'est pas, et l'affirmation qu'il "n'est pas sans danger comme l'écrit" est erroné.
- Je vais régler ça à faire de mon point de vue plus claire.
- Il suffit de prendre le entre parenthèses. Il n'y a pas besoin de prendre des coups bas à sprintf.
- Mais le *f famille de fonctions sont si faciles à prendre des coups de pot au ...
InformationsquelleAutor Zac Howland

Sans C++11, vous pouvez écrire votre propre to_string fonction:

string to_string(double x) {
  ostringstream x_convert;
  x_convert << x;
  return x_convert.str();
}

InformationsquelleAutor vz0

1

Avec C++11, comme mentionné par d'autres, l'utilisation std::to_string.

Sans C++11, vous êtes coincé avec le code que vous avez déjà écrit, ou quelque chose le long de ces lignes. Vous pouvez rendre l'utilisation de ce code un peu plus élégante (lire: moins de frappe) par la construction d'un appareil qui ne la chaîne de la construction pour vous:
```
class StringBuilder
{
public:
    template <typename T> inline StringBuilder& operator<<(const T& t)
    {
        mStream << t;
        return * this;
    }
    inline std::string get() const
    {
        return mStream.str();
    }
    inline operator std::string () const
    {
        return get();
    }
private:
    std::stringstream mStream;
};
```
Maintenant, vous pouvez:
```
double x;
string x_str = StringBuilder() << x;
```
Mais à la fin de la journée, c'est vraiment juste sucre syntaxique pour la même chose. Il y a des dispositifs similaires dans coup de pouce-j'aimerais utiliser ces si vous le pouvez.

InformationsquelleAutor John Dibling

Vous devez vous connecter pour publier un commentaire.