Le moyen le plus simple de convertir un entier en chaîne en C ++

Quelle est la façon la plus simple de convertir inten équivalent stringen C ++. Je connais deux méthodes. Existe-t-il un moyen plus simple?

(1)

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

(2)

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

C ++ 11 introduit std::stoi(et variantes pour chaque type numérique) et std::to_string, les homologues du C atoiet itoamais exprimés en terme de std::string.

#include <string> 

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

est donc le moyen le plus court auquel je peux penser. Vous pouvez même omettre de nommer le type à l'aide du automot clé:

auto s = std::to_string(42);

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

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 à l'origine basée sur les macros (conservée ci-dessous) sans passer par la laideur des macros.

// variadic template
template < typename... Args >
std::string sstr( Args &&... args )
{
    std::ostringstream sstr;
    // fold expression
    ( 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:

Puisque la "conversion ... en chaîne" est un problème récurrent, je définis toujours 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'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 C ++ 98 (si vous ne pouvez pas utiliser C ++ 11 std::to_string), et n'a pas besoin d'inclusions tierces (si vous ne pouvez pas utiliser Boost lexical_cast<>); ces deux autres solutions ont cependant de meilleures performances.

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();
  }

Il est décrit en détail ici .

Le moyen le plus courant est probablement le plus simple de votre deuxième choix dans un modèle nommé lexical_cast, tel que celui de Boost , donc votre code ressemble à ceci:

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

Une des particularités de ceci est qu'il prend également en charge d'autres modèles (par exemple, dans le sens opposé, il fonctionne tout aussi bien).

Notez également que bien que Boost lexical_cast ait commencé comme une simple écriture dans un flux de chaînes, puis une extraction en retour du flux, il a maintenant quelques ajouts. Tout d'abord, des spécialisations pour un certain nombre de types ont été ajoutées, donc pour de nombreux 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 d'une chaîne en un int, il peut lever une exception si la chaîne contient quelque chose qui n'a pas pu être converti en un int(par exemple, 1234réussirait, mais 123abclancerait) .

Depuis C ++ 11, il existe une std::to_stringfonction surchargée pour les types entiers, vous pouvez donc utiliser du code comme:

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

La norme les définit comme équivalant à effectuer la conversion avec sprintf(en utilisant le spécificateur de conversion qui correspond au type d'objet fourni, comme %dpour int), dans un tampon de taille suffisante, puis en créant un std::stringdu contenu de ce tampon.

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

#include <boost/lexical_cast.hpp>

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

Il serait 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 créez 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 fonctionner, et c'est assez court.

Vous pouvez utiliser std::to_stringdisponible en C ++ 11 comme suggéré par Matthieu M .:

std::to_string(42);

Ou, si les performances sont critiques (par exemple, si vous effectuez de nombreuses conversions), vous pouvez utiliser fmt::format_intla bibliothèque {fmt} pour convertir un entier en std::string:

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

Ou une chaîne C:

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

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

Notez que les deux sont thread-safe.

Contrairement à std::to_string, fmt::format_intne nécessite pas C ++ 11 et fonctionne avec n'importe quel compilateur C ++.

Avertissement: je suis l'auteur de la bibliothèque {fmt}.

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

Incluez d'abord:

#include <string>
#include <sstream>

Ajoutez ensuite la méthode:

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

Utilisez la méthode comme ceci:

NumberToString(69);

ou

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

L'utilisation de stringstream pour la conversion de nombres est dangereuse!

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

Selon vos paramètres régionaux actuels, un entier supérieur à 3 chiffres peut être converti en une chaîne de 4 chiffres, en ajoutant un séparateur de milliers supplémentaire.

Par exemple, int = 1000pourrait être converti en chaîne1.001 . Cela pourrait empêcher les opérations de comparaison de fonctionner.

Je recommande donc fortement d'utiliser le std::to_stringchemin. C'est plus facile et fait ce que vous attendez.

Mise à jour (voir commentaires ci-dessous) :

C ++ 17 fournit std::to_charsune alternative indépendante des paramètres régionaux plus performante

Pour C ++ 98 , il existe quelques options:

boost/lexical_cast

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

Le lexical_castmodèle de fonction offre une forme pratique et cohérente pour prendre en charge les conversions courantes vers et depuis des types arbitraires lorsqu'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;
}

Quant à l'exécution, l' lexical_castopération prend environ 80 microsecondes (sur ma machine) lors de la première conversion, puis accélère considérablement par la suite si elle est redondante.

itoa

Cette fonction n'est pas définie dans ANSI-C et ne fait pas partie de C ++, mais est prise en charge par certains compilateurs.
- cplusplus.com

Cela signifie que gcc/ g++ne peut pas compiler de code à l'aide de 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;
}

Aucun temps d'exécution à signaler. Je n'ai pas Visual Studio installé, qui est censé être 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;
}

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

stringstream

C'est le principal moyen de la bibliothèque C ++ de convertir des entiers en chaînes, et vice versa. Il existe des fonctions sœurs similaires stringstreamqui limitent davantage l'utilisation prévue du flux, telles que ostringstream. L'utilisation ostringstreamindique spécifiquement au lecteur de votre code que vous avez uniquement l'intention d'utiliser l' <<opérateur, essentiellement. Cette fonction est tout ce qui est particulièrement nécessaire pour convertir un entier en chaîne. Voir cette question pour une discussion plus élaborée.

#include <sstream>
#include <string>

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

Quant à l'exécution, l' ostringstreamopération prend environ 71 microsecondes (sur ma machine), puis accélère considérablement par la suite si elle est redondante, mais pas autant que les fonctions précédentes .

Bien sûr, il existe d'autres options, et vous pouvez même en intégrer une dans votre propre fonction, mais cela offre un aperçu analytique de certaines des plus populaires.

C ++ 17 fournit std :: to_chars comme une alternative indépendante des paramètres régionaux plus performante.

Il est assez facile d'ajouter du sucre syntaxique qui permet de composer des chaînes à la volée d'une manière semblable à un flux

#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 lui) strmake()et l'utiliser à la place d'unstd::string .

Exemple:

#include <iostream>

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

ÉDITÉ. Si vous avez besoin d' une conversion rapide d'un entier avec un nombre fixe de chiffres en char * rempli à gauche avec '0' , voici l'exemple pour les architectures peu endiennes (toutes x86, x86_64 et autres):

Si vous convertissez un nombre à deux chiffres:

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

Si vous convertissez un nombre à trois chiffres:

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

Si vous convertissez un nombre à 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. Dans cet exemple, nest un entier donné. Après la conversion, sa représentation sous forme de chaîne est accessible comme suit (char*)&s:

std::cout << (char*)&s << std::endl;

REMARQUE: Si vous en avez besoin sur l'ordre des octets big-endian, bien que je ne l'ai pas testé, mais voici un exemple: pour un nombre à trois chiffres, c'est int32_t s = 0x00303030 | (n/100)<< 24 | (n/10%10)<<16 | (n%10)<<8;pour des nombres à quatre chiffres (64 bits arch): int64_t s = 0x0000000030303030 | (n/1000)<<56 | (n/100%10)<<48 | (n/10%10)<<40 | (n%10)<<32;Je pense que cela devrait fonctionner.

Utilisation:

#define convertToString(x) #x

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

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 g ++ Windows et Linux.

Voici un autre moyen simple de le faire

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

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

Vous pouvez convertir un char *tableau en chaîne comme indiqué sur la troisième ligne.

Cela a fonctionné pour moi -

Mon code:

#include <iostream>
using namespace std;

int main()
{
    int n = 32;
    string s = to_string(n);
    cout << "string: " + s  << endl;
    return 0;
}

C ++ 11 introduit std::to_string()pour les types numériques:

int n = 123; // Input, signed/unsigned short/int/long/long long/float/double
std::string str = std::to_string(n); // Output, std::string

Utilisation:

#include<iostream>
#include<string>

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;
}

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;
}

Si vous utilisez MFC , vous pouvez utiliser CString:

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

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

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).

Je pense que l'utilisation stringstreamest assez simple:

 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 d'algorithme de compteur pour convertir en chaîne. J'ai obtenu cette technique en programmant des ordinateurs Commodore 64 . Il est également bon pour la programmation de jeux.

• Vous prenez l'entier et prenez chaque chiffre qui est pondéré par des puissances de 10. Supposons donc que l'entier est 950.

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

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

• Lâchez une autre puissance de dix

• Répétez le motif

Je sais que 950 est trop petit pour être utilisé comme exemple, mais j'espère que vous avez compris.