Conversion d’un int en std :: ssortingng

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

 int i = 3; std::ssortingng str = std::to_ssortingng(i); 

 #include  #include  const int i = 3; std::ossortingngstream s; s << i; const std::string i_as_string(s.str()); 

boost::lexical_cast(yourint) partir de boost/lexical_cast.hpp

Travailler pour tout avec le support std :: ostream, mais n’est pas aussi rapide que, par exemple, itoa

Il semble même être plus rapide que ssortingngstream ou scanf:

• http://www.boost.org/doc/libs/1_53_0/doc/html/boost_lexical_cast/performance.html

La manière bien connue de faire cela est d’utiliser l’opérateur de stream:

 #include  std::ossortingngstream s; int i; s << i; std::string converted(s.str()); 

Bien sûr vous pouvez le généraliser pour tout type utilisant une fonction template ^^

 #include  template std::ssortingng toSsortingng(const T& value) { std::ossortingngstream oss; oss << value; return oss.str(); } 

Fonction non standard, mais implémentée sur les compilateurs les plus courants:

 int input = MY_VALUE; char buffer[100] = {0}; int number_base = 10; std::ssortingng output = itoa(input, buffer, number_base); 

Mettre à jour

C ++ 11 a introduit plusieurs surcharges std::to_ssortingng (notez que la valeur par défaut est base-10).

Si vous ne pouvez pas utiliser std::to_ssortingng partir de C ++ 11, vous pouvez l’écrire tel que défini sur cppreference.com:

std::ssortingng to_ssortingng( int value ) Convertit un entier décimal signé en une chaîne ayant le même contenu que ce que std::sprintf(buf, "%d", value) produirait pour un buf suffisamment grand.

la mise en oeuvre

 #include  #include  #include  std::ssortingng to_ssortingng( int x ) { int length = snprintf( NULL, 0, "%d", x ); assert( length >= 0 ); char* buf = new char[length + 1]; snprintf( buf, length + 1, "%d", x ); std::ssortingng str( buf ); delete[] buf; return str; } 

Vous pouvez faire plus avec elle. Utilisez simplement "%g" pour convertir float ou double en ssortingng, utilisez "%x" pour convertir int en représentation hexadécimale, etc.

La macro suivante n’est pas aussi compacte qu’un ossortingngstream ou boost::lexical_cast usage ossortingngstream boost::lexical_cast .

Mais si vous avez besoin de conversion en chaîne à plusieurs resockets dans votre code, cette macro est plus élégante à utiliser que la gestion directe de chaînes de caractères ou de transtypages explicites à chaque fois.

Il est également très polyvalent, car il convertit tout ce qui est supporté par operator<<() , même en combinaison.

Définition:

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

Explication:

Le std::dec est un moyen sans effet secondaire de faire de l' ossortingngstream anonyme dans un ostream générique, donc la recherche de la fonction d' operator<<() fonctionne correctement pour tous les types. (Vous rencontrez des problèmes si le premier argument est un type de pointeur.)

Le dynamic_cast renvoie le type à ossortingngstream afin que vous puissiez appeler str() dessus.

Utilisation:

 #include  int main() { int i = 42; std::ssortingng s1 = SSTR( i ); int x = 23; std::ssortingng s2 = SSTR( "i: " << i << ", x: " << x ); return 0; } 

Vous pourriez inclure l’implémentation de itoa dans votre projet.
Voici itoa modifié pour fonctionner avec std :: ssortingng: http://www.strudel.org.uk/itoa/

Supposons que j’ai un integer = 0123456789101112 . Maintenant, cet entier peut être converti en chaîne par la classe ssortingngstream .

Voici le code en C ++:

  #include  using namespace std; int main() { int n,i; ssortingng s; ssortingngstream st; for(i=0;i<=12;i++) { st<