c ++ analyse int de chaîne

Question

Dupliquer possible:
Comment analyser une chaîne à un int en C ++?

J'ai fait des recherches et certaines personnes disent utiliser atio et d'autres disent que c'est mauvais, et je ne peux pas le faire fonctionner de toute façon.

Donc, je veux juste demander à plat, quelle est la bonne façon de convertir une chaîne en un int.

 string s = "10";
int i = s....?
 

Merci!

Answer 1

• En C++11, utilisez std::stoi comme:

  std::string s = "10";
  int i = std::stoi(s);
  

  Notez que std::stoi lèvera une exception de type std::invalid_argument si la conversion ne peut pas être effectuée, ou std::out_of_range si les résultats de la conversion dans le débordement(j'.e lorsque la valeur de la chaîne est trop grand pour int type). Vous pouvez utiliser std::stol ou std:stoll bien qu'en cas int semble trop petite pour la chaîne d'entrée.

• En C++03/98, les opérations suivantes peuvent être utilisées:

  std::string s = "10";
  int i;
  
  //approach one
  std::istringstream(s) >> i; //i is 10 after this
  
  //approach two
  sscanf(s.c_str(), "%d", &i); //i is 10 after this
  

Notez que les deux approches ci-dessus serait un échec pour l'entrée s = "10jh". Ils seront de retour 10 au lieu de notification d'erreur. De sorte que la sécurité et la fiabilité de l'approche est d'écrire votre propre fonction qui analyse la chaîne d'entrée, et de vérifier chaque personnage afin de vérifier si c'est des chiffres ou pas, et puis le travail en conséquence. Voici une implémentation robuste (bien que non testé):

int to_int(char const *s)
{
     if ( s == NULL || *s == '\0' )
        throw std::invalid_argument("null or empty string argument");

     bool negate = (s[0] == '-');
     if ( *s == '+' || *s == '-' ) 
         ++s;

     if ( *s == '\0')
        throw std::invalid_argument("sign character only.");

     int result = 0;
     while(*s)
     {
          if ( *s >= '0' && *s <= '9' )
          {
              result = result * 10  - (*s - '0');  //assume negative number
          }
          else
              throw std::invalid_argument("invalid input string");
          ++s;
     }
     return negate ? result : -result; //-result is positive!
} 

Cette solution est la version légèrement modifiée de mon autre solution.

Answer 2

Vous pouvez utiliser boost :: lexical_cast :

 #include <iostream>
#include <boost/lexical_cast.hpp>

int main( int argc, char* argv[] ){
std::string s1 = "10";
std::string s2 = "abc";
int i;

   try   {
      i = boost::lexical_cast<int>( s1 );
   }
   catch( boost::bad_lexical_cast & e ){
      std::cout << "Exception caught : " << e.what() << std::endl;
   }

   try   {
      i = boost::lexical_cast<int>( s2 );
   }
   catch( boost::bad_lexical_cast & e ){
      std::cout << "Exception caught : " << e.what() << std::endl;
   }

   return 0;
}
 

Answer 3

Vous pouvez utiliser istringstream .

 string s = "10";

// create an input stream with your string.
istringstream is(str);

int i;
// use is like an input stream
is >> i;
 

Answer 4

Il n'y a pas de "bonne façon". Si vous voulez un universel (mais sous-optimale) solution, vous pouvez utiliser un boost::lexicale en fonte.

Une solution commune pour le C++ est d'utiliser std::ostream et l'opérateur<<. Vous pouvez utiliser un stringstream et stringstream::str() méthode pour la conversion en chaîne de caractères.

Si vous avez vraiment besoin d'un mécanisme rapide (rappelez-vous la règle des 20/80) vous pouvez rechercher un "dédié" comme solution http://www.partow.net/programming/strtk/index.html

Meilleures Salutations,
Marcin

Answer 5

Quelques fonctions rapides pratiques (si vous n'utilisez pas Boost):

 template<typename T>
std::string ToString(const T& v)
{
    std::ostringstream ss;
    ss << v;
    return ss.str();
}

template<typename T>
T FromString(const std::string& str)
{
    std::istringstream ss(str);
    T ret;
    ss >> ret;
    return ret;
}
 

Exemple:

 int i = FromString<int>(s);
std::string str = ToString(i);
 

Fonctionne pour tous les types de flux (flotteurs, etc.). Vous aurez besoin de #include <sstream> et éventuellement aussi de #include <string> .