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




to_string is not a member of std (18)

Quel est le moyen le plus simple de convertir d' int en string équivalente 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();

Vous utilisez un type d'algorithme de compteur pour convertir en une chaîne. J'ai eu cette technique de programmation Commodore 64 ordinateurs. C'est aussi 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 alors soustrayez 100 000 et augmentez le compteur dans la chaîne à ["000000"];
      continuez à le faire jusqu'à ce qu'il n'y ait plus de numéros en position 100 000. Drop un autre pouvoir de dix

    • Si l'entier est égal ou supérieur à 10 000 alors 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.

  • Drop un autre pouvoir de dix

  • Répéter le motif

Je sais que 950 est trop petit pour servir d'exemple, mais j'espère que vous en aurez l'idée.


Probablement le moyen le plus courant lexical_cast votre deuxième choix dans un modèle nommé lexical_cast , tel que celui de Boost , de sorte que 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 moulages (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 en un int , il peut lancer une exception si la chaîne contient quelque chose qui n'a pas pu être converti en un int (par exemple, 1234 réussirait, mais 123abc lancerait).

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

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

La norme les définit comme étant équivalent à 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 en créant une std::string du le contenu de ce tampon.


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

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


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 de bibliothèque utiles.

Le lexical_cast fonction lexical_cast offre une forme pratique et cohérente pour la prise en charge de conversions courantes vers et à partir de types arbitraires lorsqu'elles sont représentées en tant que 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;
}

En ce qui concerne l'exécution, l'opération lexical_cast prend environ 80 microsecondes (sur ma machine) lors de la première conversion, puis accélère 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 elle est supportée par certains compilateurs.
- cplusplus.com

Cela signifie que gcc / g++ ne peut pas compiler du 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 à signaler. Je n'ai pas Visual Studio installé, qui reportedly 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é comme une 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-tête stdio.h peut ne pas être nécessaire. En ce qui concerne l'exécution, l'opération sprintf prend environ 40 microsecondes (sur ma machine) lors de la première conversion, puis accélère considérablement si elle est effectuée de manière redondante.

stringstream

C'est la manière principale de la bibliothèque C ++ de convertir des entiers en chaînes, et vice versa. Il existe des fonctions soeurs similaires à la stringstream qui limitent davantage l'utilisation prévue du flux, comme ostringstream . L'utilisation d' ostringstream indique 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;
}

En ce qui concerne l'exécution, l'opération ostringstream prend environ 71 microsecondes (sur ma machine), puis accélère considérablement si elle est faite de manière redondante, mais pas autant que les fonctions précédentes .

Bien sûr, il y a d'autres options, et vous pouvez même envelopper l'une d'entre elles dans votre propre fonction, mais cela offre un regard analytique sur certaines des plus populaires.


Si vous avez besoin d'une conversion rapide d'un entier avec un nombre fixe de chiffres en char * left-padded avec '0', voici un exemple pratique:

int n = 27;
char s[8];

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 chiffres :)


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

Utilisation:

#define convertToString(x) #x

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

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)


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

sprintf() est plutôt 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 dans 1.


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

std::to_string(42);

Ou, si les performances sont critiques (par exemple, si vous faites beaucoup de conversions), vous pouvez utiliser fmt::FormatInt de la bibliothèque C ++ Format pour convertir un entier en std::string :

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

Ou une chaîne C:

fmt::FormatInt 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_string sur les benchmarks Boost Karma. Voir Intégration rapide à la conversion de chaînes en C ++ pour plus de détails.

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

Disclaimer: Je suis l'auteur de la bibliothèque C ++ Format.


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

D'abord inclure:

#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 comme ceci:

NumberToString(69);

ou

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

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.


Comme "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'inclure des tiers (si vous ne pouvez pas utiliser Boost lexical_cast<> ); ces deux autres solutions ont une meilleure performance cependant.


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


Voici un autre moyen facile de faire

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

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

Vous pouvez convertir char * array en chaîne comme indiqué dans la troisième ligne.


Il est plutôt facile d'ajouter un peu de sucre syntaxique qui permet de composer des cordes à la volée de manière fluide

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

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

Exemple:

#include <iostream>

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






type-conversion