Comment convertir un nombre en chaîne et vice versa en C ++

Mise à jour pour C ++ 11

A partir de la norme C++11 , la conversion de chaîne en nombre et inversement est intégrée à la bibliothèque standard. Toutes les fonctions suivantes sont présentes dans (conformément au paragraphe 21.5).

chaîne à numeric

 float stof(const ssortingng& str, size_t *idx = 0); double stod(const ssortingng& str, size_t *idx = 0); long double stold(const ssortingng& str, size_t *idx = 0); int stoi(const ssortingng& str, size_t *idx = 0, int base = 10); long stol(const ssortingng& str, size_t *idx = 0, int base = 10); unsigned long stoul(const ssortingng& str, size_t *idx = 0, int base = 10); long long stoll(const ssortingng& str, size_t *idx = 0, int base = 10); unsigned long long stoull(const ssortingng& str, size_t *idx = 0, int base = 10); 

Chacun d’eux prend une chaîne en entrée et essaiera de le convertir en nombre. Si aucun nombre valide ne peut être construit, par exemple parce qu’il n’y a pas de données numériques ou que le nombre est hors limites pour le type, une exception est std::invalid_argument ( std::invalid_argument ou std::out_of_range ).

Si la conversion a réussi et que idx n’est pas 0 , idx contiendra l’index du premier caractère qui n’a pas été utilisé pour le décodage. Cela pourrait être un index derrière le dernier caractère.

Enfin, les types intégraux permettent de spécifier une base, pour les chiffres supérieurs à 9, l’alphabet est supposé ( a=10 jusqu’à z=35 ). Vous pouvez trouver plus d’informations sur la mise en forme exacte qui peut être analysée ici pour les nombres à virgule flottante , les entiers signés et les entiers non signés .

Enfin, pour chaque fonction, il existe aussi une surcharge qui accepte un std::wssortingng comme premier paramètre.

numérique à chaîne

 ssortingng to_ssortingng(int val); ssortingng to_ssortingng(unsigned val); ssortingng to_ssortingng(long val); ssortingng to_ssortingng(unsigned long val); ssortingng to_ssortingng(long long val); ssortingng to_ssortingng(unsigned long long val); ssortingng to_ssortingng(float val); ssortingng to_ssortingng(double val); ssortingng to_ssortingng(long double val); 

Celles-ci sont plus simples, vous transmettez le type numérique approprié et vous récupérez une chaîne. Pour les options de formatage, vous devez revenir à l’option C ++ 03 ssortingngsream et utiliser des manipulateurs de stream, comme expliqué dans une autre réponse ici.

Comme indiqué dans les commentaires, ces fonctions retombent sur une précision de mantisse par défaut qui n’est probablement pas la précision maximale. Si plus de précision est requirejse pour votre application, il est également préférable de revenir aux autres procédures de formatage de chaîne.

Il existe également des fonctions similaires qui sont nommées to_wssortingng , celles-ci std::wssortingng un std::wssortingng .

Comment convertir un nombre en chaîne en C ++ 03

1. N’utilisez pas les fonctions itoa ou itof car elles sont non standard et donc non portables.

2. Utiliser des stream de chaînes

     #include  //include this to use ssortingng streams #include  int main() { int number = 1234; std::ossortingngstream ostr; //output ssortingng stream ostr << number; //use the string stream just like cout, //except the stream prints not to stdout but to a string. std::string theNumberString = ostr.str(); //the str() function of the stream //returns the string. //now theNumberString is "1234" } 

   Notez que vous pouvez également utiliser des stream de chaînes pour convertir des nombres à virgule flottante en chaîne, ainsi que pour formater la chaîne à votre guise, comme avec cout

    std::ossortingngstream ostr; float f = 1.2; int i = 3; ostr << f << " + " i << " = " << f + i; std::string s = ostr.str(); //now s is "1.2 + 3 = 4.2" 

   Vous pouvez utiliser des manipulateurs de stream, tels que std::endl , std::hex et functions std::setw() , std::setprecision() etc. avec des stream de chaînes exactement comme avec cout

   Ne confondez pas std::ossortingngstream avec std::ostrstream . Ce dernier est déconseillé

3. Utilisez le lancer lexical boost . Si vous n'êtes pas familier avec Boost, il est conseillé de commencer avec une petite bibliothèque telle que le lexical_cast. Pour télécharger et installer boost et sa documentation, cliquez ici . Bien que boost ne soit pas dans la norme C ++, de nombreuses bibliothèques de boost sont finalement standardisées et boost est largement considéré comme la meilleure des bibliothèques C ++.

   Le cast Lexical utilise des stream en dessous, donc en gros cette option est la même que la précédente, juste moins verbeuse.

    #include  #include  int main() { float f = 1.2; int i = 42; std::ssortingng sf = boost::lexical_cast(f); //sf is "1.2" std::ssortingng si = boost::lexical_cast(i); //sf is "42" } 

Comment convertir une chaîne en nombre en C ++ 03

1. L'option la plus légère, héritée de C, est les fonctions atoi (pour les entiers (alphabétique à entier)) et atof (pour les valeurs à virgule flottante (alphabétique à flotter)). Ces fonctions prennent une chaîne de style C comme argument ( const char * ) et leur utilisation peut donc être considérée comme une mauvaise pratique C ++. cplusplus.com a une documentation facile à comprendre à la fois sur atoi et atof, y compris la façon dont ils se comportent en cas de mauvaise saisie. Cependant, le lien contient une erreur en ce sens que, selon la norme, si le nombre en entrée est trop grand pour tenir dans le type de cible, le comportement n'est pas défini.

    #include  //the standard C library header #include  int main() { std::ssortingng si = "12"; std::ssortingng sf = "1.2"; int i = atoi(si.c_str()); //the c_str() function "converts" double f = atof(sf.c_str()); //std::ssortingng to const char* } 

2. Utilisez des stream de chaînes (cette fois, le stream de chaînes d'entrée, issortingngstream ). Encore une fois, issortingngstream est utilisé comme cin . Encore une fois, ne confondez pas issortingngstream avec istrstream . Ce dernier est obsolète.

    #include  #include  int main() { std::ssortingng inputSsortingng = "1234 12.3 44"; std::issortingngstream istr(inputSsortingng); int i1, i2; float f; istr >> i1 >> f >> i2; //i1 is 1234, f is 12.3, i2 is 44 } 

3. Utilisez le lancer lexical boost .

    #include  #include  int main() { std::ssortingng sf = "42.2"; std::ssortingng si = "42"; float f = boost::lexical_cast(sf); //f is 42.2 int i = boost::lexical_cast(si); //i is 42 } 

   En cas de mauvaise entrée, lexical_cast lance une exception de type boost::bad_lexical_cast

En C ++ 17, les nouvelles fonctions std :: to_chars et std :: from_chars sont introduites dans header charconv .

std :: to_chars est indépendant des parameters régionaux, non alloué et non lanceur.

Seul un petit sous-ensemble de stratégies de formatage utilisées par d’autres bibliothèques (telles que std :: sprintf) est fourni.

De std :: to_chars , même pour std :: from_chars .

La garantie que std :: from_chars puisse récupérer chaque valeur à virgule flottante formatée par to_chars est uniquement fournie si les deux fonctions sont issues de la même implémentation

  // See en.cppreference.com for more information, including format control. #include  #include  #include  #include  #include  using Type = /* Any fundamental type */ ; std::size_t buffer_size = /* ... */ ; [[noreturn]] void report_and_exit(int ret, const char *output) noexcept { std::printf("%s\n", output); std::exit(ret); } void check(const std::errc &ec) noexcept { if (ec ==  std::errc::value_too_large) report_and_exit(1, "Failed"); } int main() { char buffer[buffer_size]; Type val_to_be_converted, result_of_converted_back; auto result1 = std::to_chars(buffer, buffer + buffer_size, val_to_be_converted); check(result1.ec); *result1.ptr = '\0'; auto result2 = std::from_chars(buffer, result1.ptr, result_of_converted_back); check(result2.ec); assert(val_to_be_converted == result_of_converted_back); report_and_exit(0, buffer); } 

Bien qu’il ne soit pas complètement implémenté par les compilateurs, il sera définitivement implémenté.

J’ai volé cette classe de quelque part ici à StackOverflow pour convertir tout ce qui peut être diffusé en chaîne:

 // make_ssortingng class make_ssortingng { public: template  make_ssortingng& operator<<( T const & val ) { buffer_ << val; return *this; } operator std::string() const { return buffer_.str(); } private: std::ostringstream buffer_; }; 

Et puis vous l'utilisez comme;

 ssortingng str = make_ssortingng() << 6 << 8 << "hello"; 

Assez chouette!

De plus, j'utilise cette fonction pour convertir des chaînes en contenu pouvant être diffusé, mais ce n'est pas très sûr si vous essayez d'parsingr une chaîne ne contenant pas de nombre. (et ce n'est pas aussi intelligent que le dernier non plus)

 // parse_ssortingng template  RETURN_TYPE parse_ssortingng(const STRING_TYPE& str) { std::ssortingngstream buf; buf << str; RETURN_TYPE val; buf >> val; return val; } 

Utilisé comme:

 int x = parse_ssortingng("78"); 

Vous pourriez aussi vouloir des versions pour wssortingngs.