La façon la plus facile de convertir int en chaîne en C++

reprenant une discussion avec @v. oddou quelques années plus tard, C++17 a finalement fourni un moyen de faire la solution type-agnostique basée à l'origine sur macro (préservée ci-dessous) sans en passant par la solution macro.

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

Utilisation:

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:

depuis " conversion ... à la chaîne" est un problème récurrent, je toujours définir la macro SSTR () 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'Usage 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 C++98 (si vous ne pouvez pas utiliser C++11 std::to_string ), et n'a pas besoin de tiers inclut (Si vous ne pouvez pas utiliser Boost lexical_cast<> ); ces deux autres solutions ont une meilleure performance cependant.

j'utilise habituellement 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étail ici .

probablement la manière la plus commune enveloppe facile essentiellement votre deuxième choix dans un modèle appelé lexical_cast , comme celui dans Boost , donc votre code ressemble à ceci:

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

Un concept est qu'il prend en charge d'autres distributions (par exemple, dans la direction opposée fonctionne tout aussi bien).

notez aussi que même si Boost lexical_cast a commencé par simplement écrire à un stringstream, puis extraire de nouveau hors du ruisseau, il a maintenant un couple d'ajouts. Tout d'abord, des spécialisations pour quelques types ont été ajoutées, donc pour beaucoup de types courants, c'est beaucoup plus rapide que d'utiliser un stringstream. Deuxièmement, il vérifie maintenant le résultat , donc (par exemple) si vous convertissez une chaîne en int , il peut lancer une exception si la chaîne contient quelque chose qui ne pourrait pas être converti en int (par exemple, 1234 réussirait, mais 123abc lancerait).

depuis C++11, Il y a une fonction std::to_string surchargée pour les types entiers, donc vous pouvez utiliser le code comme:

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

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

si vous avez Boost installé (ce que vous devez faire):

#include <boost/lexical_cast.hpp>

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

ne serait-il pas plus simple d'utiliser stringstream?

#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 créer une fonction:

#include <sstream>

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

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

string s = string(itoa(a));

devrait marcher, et c'est assez court.

sprintf() est assez bon pour la conversion de format. Vous pouvez alors assigner la chaîne c résultante à la chaîne C++ comme vous l'avez fait dans 1.

inclut d'Abord:

#include <string>
#include <sstream>

deuxième ajouter la méthode:

template <typename T>
string NumberToString(T pNumber)
{
 ostringstream oOStrStream;
 oOStrStream << pNumber;
 return oOStrStream.str();
}

utilisez la méthode suivante:

NumberToString(69);

ou

int x = 69;
string vStr = NumberToString(x) + " Hello word!."

vous pouvez utiliser std::to_string disponible en C++11 comme suggéré par Matthieu M. :

std::to_string(42);

ou, si la performance est critique (par exemple, si vous faites beaucoup de conversions), vous pouvez utiliser fmt::FormatInt de la Format C++ bibliothèque pour convertir un entier en std::string :

fmt::FormatInt(42).str();

ou une chaîne en C:

fmt::FormatInt f(42);
f.c_str();

ce dernier ne fait aucune dynamique de mémoire et est plus de 10 fois plus rapide que std::to_string sur Boost Karma benchmarks. Voir Conversion rapide d'un entier en chaîne en C++ pour plus de détails.

contrairement à std::to_string , fmt::FormatInt ne nécessite pas de C++11 et fonctionne avec n'importe quel compilateur C++.

Avertissement: je suis l'auteur du C++ Format de la bibliothèque.

utiliser stringstream pour la conversion des nombres est dangereux!

voir http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C / où il indique que operator<< insère la sortie formatée.

en fonction de votre localisation actuelle un entier supérieur à 3 chiffres, pourrait convertir en une chaîne de 4 chiffres, en ajoutant un séparateur de milliers supplémentaires.

par exemple, int = 1000 pourrait être convertet à une chaîne de caractères 1.001 . Cela pourrait faire que les opérations de comparaison ne fonctionnent pas du tout.

donc je recommande fortement d'utiliser la méthode std::to_string . Il est plus facile et fait ce que vous attendez.

pour C++98 , il y a quelques options:

boost/lexical_cast

Boost ne fait pas partie de la bibliothèque C++, mais contient de nombreuses extensions utiles.

le modèle de fonction lexical_cast offre une forme pratique et cohérente pour supporter les conversions courantes vers et à partir de types arbitraires quand ils sont représentés sous forme de texte.

-- documentation de Boost

#include "boost/lexical_cast.hpp"
#include <string>

int main() {
    int x = 5;
    std::string x_str = boost::lexical_cast<std::string>(x);
    return 0;
}

comme pour l'exécution, l'opération lexical_cast prend environ 80 microsecondes (sur ma machine) lors de la première conversion, et accélère ensuite considérablement si elle est effectuée de manière redondante.

itoa

cette fonction n'est pas définie dans ANSI-C et ne fait pas partie de C++, mais est supportée par certains compilateur.

-- cplusplus.com

cela signifie que gcc / g++ ne peut pas compiler le code en utilisant itoa .

#include <stdlib.h>

int main() {
    int x = 5;
    char * x_str = new char[2];
    x_str = itoa(x, x_str, 10); // base 10
    return 0;
}

Pas d'exécution de rapport. Je n'ai pas Visual Studio installé, qui est apparemment capable de compiler itoa .

sprintf

sprintf est une fonction de bibliothèque standard C qui fonctionne sur les chaînes C, et est une alternative parfaitement valide.

compose une chaîne avec le même texte qui serait imprimé si le format était utilisé sur printf, mais au lieu d'être imprimé, le contenu est stocké sous forme de chaîne C dans le tampon pointé par str.

-- cplusplus.com

#include <stdio.h>

int main() {
    int x = 5;
    char * x_str = new char[2];
    int chars_written = sprintf(x_str, "%d", x);
    return 0;
}

le L'en-tête stdio.h peut ne pas être nécessaire. Quant à l'exécution, l'opération sprintf prend environ 40 microsecondes (sur ma machine) lors de la première conversion, et accélère ensuite considérablement si elle est effectuée de manière redondante.

stringstream

C'est la principale façon pour la bibliothèque C++ de convertir des entiers en chaînes, et vice versa. Il existe des fonctions similaires à stringstream qui limitent davantage l'utilisation prévue du ruisseau, comme ostringstream . L'utilisation de ostringstream indique spécifiquement au lecteur de votre code que vous avez seulement l'intention d'utiliser l'opérateur << , essentiellement. Cette fonction est particulièrement nécessaire pour convertir un entier en une chaîne de caractères. Voir cette question pour une discussion plus détaillée.

#include <sstream>
#include <string>

int main() {
    int x = 5;
    std::ostringstream stream;
    stream << x;
    std::string x_str = stream.str();
    return 0;
}

comme pour l'exécution, l'opération ostringstream prend environ 71 microsecondes (sur ma machine), puis accélère pas autant que les fonctions précédentes .

bien sûr, il ya d'autres options, et vous pouvez même envelopper l'un de ces dans votre propre fonction, mais cela offre un regard analytique à certaines des populaires.

utiliser:

#define convertToString(x) #x

int main()
{
    convertToString(42); // Returns const char* equivalent of 42
}

il est assez facile d'ajouter un peu de sucre syntaxique qui permet de composer des cordes à la volée comme un ruisseau

#include <string>
#include <sstream>

struct strmake {
    std::stringstream s;
    template <typename T> strmake& operator << (const T& x) {
        s << x; return *this;
    }   
    operator std::string() {return s.str();}
};

vous pouvez maintenant ajouter ce que vous voulez (à condition qu'un opérateur << (std::ostream& ..) soit défini pour cela) à strmake() et l'utiliser à la place d'un std::string .

exemple:

#include <iostream>

int main() {
    std::string x =
      strmake() << "Current time is " << 5+5 << ":" << 5*5 << " GST";
    std::cout << x << std::endl;
}

namespace std
{
    inline string to_string(int _Val)
    {   // convert long long to string
        char _Buf[2 * _MAX_INT_DIG];
        snprintf(_Buf, "%d", _Val);
        return (string(_Buf));
    }
}

vous pouvez maintenant utiliser to_string(5)

j'utilise:

int myint = 0;
long double myLD = 0.0;

string myint_str = static_cast<ostringstream*>( &(ostringstream() << myint) )->str();
string myLD_str = static_cast<ostringstream*>( &(ostringstream() << myLD) )->str();

il fonctionne sur mes compilateurs windows et linux g++.

par CString :

int a = 10;
CString strA;
strA.Format("%d", a);

string number_to_string(int x){
    if(!x) return "0";
        string s,s2;
        while(x){
            s.push_back(x%10 + '0');
            x/=10;
        }
    reverse(s.begin(),s.end());
    return s;
}

#include "stdafx.h"
#include<iostream>
#include<string>
#include<string.h>


std::string intToString(int num);

int main()
{

    int integer = 4782151;

    std::string integerAsStr = intToString(integer);

    std::cout << "integer = " << integer << std::endl;
    std::cout << "integerAsStr = " << integerAsStr << std::endl;


    return 0;
}

std::string intToString(int num)
{
    std::string numAsStr;

    while (num)
    {
        char toInsert = (num % 10) + 48;
        numAsStr.insert(0, 1, toInsert);

        num /= 10;
    }

    return numAsStr;
}

char * bufSecs = new char[32];
char * bufMs = new char[32];
sprintf(bufSecs,"%d",timeStart.elapsed()/1000);
sprintf(bufMs,"%d",timeStart.elapsed()%1000);

si vous avez besoin de la conversion rapide d'un entier avec un nombre fixe de chiffres à char* gauche-rembourré avec '0', c'est un exemple commode:

int n = 27;
char s[8];

si vous convertissez un numéro à deux chiffres:

*(int32_t*)s = 0x3030 | (n/10) | (n%10) << 8;

si vous convertissez un numéro à trois chiffres:

*(int32_t*)s = 0x303030 | (n/100) | (n/10%10) << 8 | (n%10) << 16;

si vous convertissez un numéro à quatre chiffres:

*(int64_t*)s = 0x30303030 | (n/1000) | (n/100%10)<<8 | (n/10%10)<<16 | (n%10)<<24;

Et ainsi de suite jusqu'à sept chiffres :)

Voici une autre façon facile de faire

char str[100] ; 
sprintf(str , "%d" , 101 ) ;  
string s = str; 

sprintf est bien connue pour insérer des données dans une chaîne de format requis .

vous pouvez convertir char * array en string comme indiqué dans la troisième ligne.

int n = 123;
std::string str = std::to_string(n);

je pense, utiliser stringstream est assez facile.

 string toString(int n)
 {
   stringstream ss(n);
   ss << n;
   return ss.str();
 }

 int main()
 {
    int n;
    cin>>n;
    cout<<toString(n)<<endl;
    return 0;
 }

vous utilisez un type de compteur d'algorithme pour convertir en chaîne. J'ai eu cette technique en programmant des ordinateurs Commodore 64 . Il est également bon pour la programmation de jeu.

• vous prenez l'entier et prenez chaque chiffre qui est pondéré par des puissances de 10. Supposons que le nombre entier soit 950.

  • si l'entier est égal ou supérieur à 100 000, soustrayez 100 000 et augmentez le compteur dans la chaîne à ["000000"];
    
    continuez jusqu'à ce qu'il n'y ait plus de numéros en position 100 000. Déposez une autre puissance de dix

  • si le nombre entier est égal ou supérieur à 10 000, soustrayez 10 000 et augmentez le compteur dans la chaîne à la position ["000000"] + 1;
    
    continuez jusqu'à ce qu'il n'y ait plus de numéros en position 10 000.

• Chute d'une puissance de dix

• Répétition du motif

je sais 950 est trop petit pour l'utiliser comme un exemple, mais j'espère que vous obtenez l'idée.