Question Le moyen le plus simple de convertir int en chaîne en C ++


Quel est le moyen le plus simple de convertir int à l'équivalent string en C ++. Je suis au courant de deux méthodes. Y a-t-il un moyen plus facile?

(1)

int a = 10;
char *intStr = itoa(a);
string str = string(intStr);

(2)

int a = 10;
stringstream ss;
ss << a;
string str = ss.str();

1208
2018-04-08 04:19


origine


Réponses:


C ++ 11 introduit std::stoi (et variantes pour chaque type numérique) et std::to_string, les contreparties du C atoi et itoa mais exprimé en terme de std::string.

#include <string> 

std::string s = std::to_string(42);

est donc le moyen le plus court que je puisse penser. Vous pouvez même omettre de nommer le type, en utilisant auto mot-clé:

auto s = std::to_string(42);

Note: voir [string.conversions] (21,5 dans n3242)


1592
2018-04-08 06:13



Reprenant une discussion avec @ v.oddou quelques années plus tard, C ++ 17 a finalement fourni un moyen de faire la solution de type agnostique à base de macros à l'origine (préservée ci-dessous) sans pour autant passer par la laideur macro.

template < typename... Args >
std::string sstr( Args &&... args )
{
    std::ostringstream sstr;
    ( sstr << std::dec << ... << args );
    return sstr.str();
}

Usage:

int i = 42;
std::string s = sstr( "i is: ", i );
puts( sstr( i ).c_str() );

Foo x( 42 );
throw std::runtime_error( sstr( "Foo is '", x, "', i is ", i ) );

Réponse originale:

Comme "convertir en chaîne" est un problème récurrent, je définis toujours SSTR () macro dans un en-tête central de mes sources C ++:

#include <sstream>

#define SSTR( x ) static_cast< std::ostringstream & >( \
        ( std::ostringstream() << std::dec << x ) ).str()

L'utilisation est aussi simple que possible:

int i = 42;
std::string s = SSTR( "i is: " << i );
puts( SSTR( i ).c_str() );

Foo x( 42 );
throw std::runtime_error( SSTR( "Foo is '" << x << "', i is " << i ) );

Ce qui précède est compatible avec C ++ 98 (si vous ne pouvez pas utiliser C ++ 11 std::to_string), et n'a pas besoin d'inclure des tiers (si vous ne pouvez pas utiliser Boost lexical_cast<>) ces deux autres solutions ont une meilleure performance cependant.


165
2018-04-08 04:23



J'utilise généralement la méthode suivante:

#include <sstream>

template <typename T>
  std::string NumberToString ( T Number )
  {
     std::ostringstream ss;
     ss << Number;
     return ss.str();
  }

décrit en détails ici.


96
2017-11-29 22:46



Probablement la façon la plus courante de contourner votre deuxième choix dans un modèle nommé lexical_cast, comme celui de Renforcer, donc votre code ressemble à ceci:

int a = 10;
string s = lexical_cast<string>(a);

Une précision de ceci est qu'il supporte aussi d'autres castes (par exemple, dans la direction opposée fonctionne tout aussi bien).

Notez également que bien que Boost lexical_cast ait débuté en écrivant simplement dans un train de chaînes, puis en extrayant de nouveau le flux, il a maintenant quelques ajouts. Tout d'abord, des spécialisations pour un certain nombre de types ont été ajoutées, donc pour beaucoup de types courants, c'est beaucoup plus rapide que d'utiliser une chaîne de caractères. Deuxièmement, il vérifie maintenant le résultat, donc (par exemple) si vous convertissez d'une chaîne à un int, il peut lancer une exception si la chaîne contient quelque chose qui n'a pas pu être converti en int (par exemple., 1234 réussirait, mais 123abc lancerait).

A partir de C ++ 11, il y a un std::to_string fonction surchargée pour les types entiers, donc vous pouvez utiliser du code comme:

int a = 20;
std::string s = to_string(a);

La norme définit ceux-ci comme étant équivalent à faire la conversion avec sprintf (en utilisant le spécificateur de conversion correspondant au type d'objet fourni, tel que %d pour int), dans un tampon de taille suffisante, puis en créant std::string du contenu de ce tampon.


84
2018-04-08 04:23



Si vous avez installé Boost (ce que vous devriez faire):

#include <boost/lexical_cast.hpp>

int num = 4;
std::string str = boost::lexical_cast<std::string>(num);

40
2018-04-08 04:26



Ne serait-il pas plus facile d'utiliser des chaînes de caractères?

#include <sstream>

int x=42;            //The integer
string str;          //The string
ostringstream temp;  //temp as in temporary
temp<<x;
str=temp.str();      //str is temp as string

Ou faire une fonction:

#include <sstream>

string IntToString (int a)
{
    ostringstream temp;
    temp<<a;
    return temp.str();
}

27
2018-04-16 19:37



Pas que je sache, en pur C ++. Mais une petite modification de ce que vous avez mentionné

string s = string(itoa(a));

devrait fonctionner, et c'est assez court.


19
2018-04-08 04:22