c++ - convert - to_string is not a member of std




Le moyen le plus simple de convertir int en chaîne en C++ (15)

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

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.


C ++ 11 introduit std::stoi (et les variantes pour chaque type numeric) et std::to_string , les contreparties des C atoi et itoa mais exprimées 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 le mot auto clé auto :

auto s = std::to_string(42);

Note: voir [string.conversions] ( 21.5 dans n3242 )


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.


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!."

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 .


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


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.


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


Utilisation de CString :

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

Utilisation:

#define convertToString(x) #x

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

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.


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.


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 que l' operator<< insère une sortie formatée.

En fonction de votre environnement local actuel, 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 = 1000 pourrait être converti en une chaîne 1.001 . Cela pourrait empêcher les opérations de comparaison de fonctionner.

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


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

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




type-conversion