Comment puis-je vérifier si une chaîne C++ est un int?

Lorsque j'utilise getline, je voudrais d'entrée d'un bouquet de chaînes de caractères ou des chiffres, mais je ne veux le tout en boucle à la sortie de la "parole", si ce n'est pas un nombre.
Donc, il y a de toute façon de vérifier si le "mot" est un nombre ou non? Je sais que je pourrais utiliser atoi() pour
C-chaînes de caractères, mais que diriez-vous pour les chaînes de la classe string?

int main () {
  stringstream ss (stringstream::in | stringstream::out);
  string word;
  string str;
  getline(cin,str);
  ss<<str;
  while(ss>>word)
    {
      //if(    )
        cout<<word<<endl;
    }
}
InformationsquelleAutor user342231 | 2010-05-16
  1. 66

    Une autre version...

    Utilisation strtol, l'enveloppant à l'intérieur d'une fonction simple de cacher sa complexité :

    inline bool isInteger(const std::string & s)
{
   if(s.empty() || ((!isdigit(s[0])) && (s[0] != '-') && (s[0] != '+'))) return false;

   char * p;
   strtol(s.c_str(), &p, 10);

   return (*p == 0);
}

    Pourquoi strtol ?

    Autant que j'aime le C++, parfois, l'API C est la meilleure réponse pour autant que je suis concerné:

    • à l'aide d'exceptions est overkill pour un test qui est autorisé à l'échec
    • les cours d'eau temporaires de création de l'objet par le lexique de fonte est exagéré, et sur-inefficace quand la bibliothèque C standard a une fonction dédiée qui fait le travail.

    Comment ça fonctionne ?

    strtol semble assez cru au premier coup d'œil, de sorte que l'explication va rendre le code plus simple à lire :

    strtol va analyser la chaîne, s'arrêtant au premier caractère qui ne peut pas être considéré comme faisant partie d'un entier. Si vous fournissez p (comme je l'ai fait ci-dessus), il définit p droit à cette première non entier de caractère.

    Mon raisonnement est que si p n'est pas réglé à la fin de la chaîne (le caractère 0), alors il existe un non-entier de caractères dans la chaîne s, sens s n'est pas une bonne entier.

    Les premiers tests sont là pour éliminer les cas de coin (grands espaces, la chaîne vide, etc.).

    Cette fonction doit être, bien sûr, adapté à vos besoins (sont les principaux espaces une erreur? etc.).

    Sources :

    Voir la description de strtol à: http://en.cppreference.com/w/cpp/string/byte/strtol.

    Voir aussi la description de strtols'sœur fonctions (strtod, strtoul, etc.).

    • +1, et de loin, la meilleure réponse. lexical_cast est exagéré, et qu'il frôle la mauvaise pratique.
    • Titarenco : lexical_cast is overkill and it borders on bad practice : lorsqu'il est utilisé à la légère, et la même chose peut être dit pour n'importe quel autre élément. L'utilisation réelle de boost::lexical_cast est pour le code générique, ou rapide et sale de code. Générique de code: Lorsque vous avez un type inconnu T, à l'aide d'un commutateur à utiliser strtol, strtol, etc. est une erreur. À l'aide d'un boost::lexical_cast est la bonne chose, en fournissant les boost::lexical_cast spécialisations pour les bons types pour une utilisation efficace. Rapide n'dirty code: Si le code n'a pas besoin de vitesse, puis à l'aide de boost::lexical_cast est la meilleure façon de le faire.
    • Pourquoi parlez-vous des exceptions et lexical_cast être exagéré, et inefficace, si vous n'avez pas de mesure (ou, si vous l'avez fait, vous n'avez pas afficher les résultats)?
    InformationsquelleAutor paercebal
  2. 56

    Accepté la réponse sera donner un faux positif si l'entrée est un nombre plus du texte, parce que "stol" va convertir les premiers chiffres et ignorer le reste.

    J'aime la suite de la version la plus, puisque c'est un joli one-liner qui n'a pas besoin de définir une fonction et que vous pouvez simplement copier et coller partout où vous en avez besoin.

    #include <string>

...

std::string s;

bool has_only_digits = (s.find_first_not_of( "0123456789" ) == std::string::npos);

    EDIT: si vous aimez cette application, mais vous ne voulez l'utiliser comme une fonction, alors cela devrait le faire:

    bool has_only_digits(const string s){
  return s.find_first_not_of( "0123456789" ) == string::npos;
}
    • "c'est un beau one-liner qui n'a pas besoin de définir une fonction et que vous pouvez simplement copier et coller partout où vous en avez besoin", mais vous devez définir une fonction. S'il vous plaît ne pas copier et de coller le code.
    • merci, triés
    • Quid des nombres négatifs?
    • Vrai, ce ne serait pas de travail pour les nombres négatifs. Mais vous pouvez vérifier si le premier caractère est un + ou un -, et si c'est le cas il suffit de passer le reste de la chaîne.
    • Wow, c'est une excellente réponse! N'aurais jamais pensé à ça
    • Ne fonctionne que pour des entiers positifs
    • c'est vrai. Si vous arrivez à le modifier pour qu'il fonctionne pour les entiers positifs et négatifs, je serais heureux de modifier ma réponse.

    InformationsquelleAutor Ferdinando Randisi
  3. 16

    Vous pouvez essayer de boost::lexical_cast. Il jette un bad_lexical_cast exception en cas d'échec.

    Dans votre cas:

    int number;
try
{
  number = boost::lexical_cast<int>(word);
}
catch(boost::bad_lexical_cast& e)
{
  std::cout << word << "isn't a number" << std::endl;
}
    InformationsquelleAutor Karl von Moor
  4. 8

    Si vous êtes juste de vérifier si word est un nombre, qui n'est pas trop dur:

    #include <ctype.h>

    ...

    string word;
bool isNumber = true;
for(string::const_iterator k = word.begin(); k != word.end(); ++k)
    isNumber &&= isdigit(*k);

    Optimiser comme souhaité.

    InformationsquelleAutor Mike DeSimone
  5. 4

    Vous pouvez utiliser boost::lexical_cast, comme l'a suggéré, mais si vous avez aucune connaissance préalable sur les chaînes de caractères (c'est à dire que si une chaîne contient un entier littéral, il n'aura pas tout l'espace de début, ou que les entiers ne sont jamais écrits avec les exposants), puis rouler votre propre fonction doit être à la fois plus efficace, et pas particulièrement difficile.

    InformationsquelleAutor James
  6. 4

    Utiliser le tout-puissant, C stdio/fonctions de chaîne:

    int dummy_int;
int scan_value = std::sscanf( some_string.c_str(), "%d", &dummy_int);

if (scan_value == 0)
    //does not start with integer
else
    //starts with integer
    • Si sscanf renvoie le nombre d'éléments appariés, alors votre exemple (commentaires) est erroné. Ou faire j'ai mal compris quelque chose?
    InformationsquelleAutor cmo
  7. 3

    Ok, la façon dont je le vois, vous avez 3 options.

    1: Si vous souhaitez tout simplement pour vérifier si le nombre est un entier, et ne se soucient pas de la conversion, mais souhaitez tout simplement de le garder comme une chaîne de caractères et ne se soucient pas de potentiels débordements, de vérifier si elle correspond à une regex pour un entier serait l'idéal ici.

    2: Vous pouvez utiliser boost::lexical_cast et ensuite de prendre un potentiel de boost::bad_lexical_cast exception pour voir si la conversion a échoué. Ce serait bien travailler si vous pouvez utiliser boost et si, à défaut de la conversion est un état exceptionnel.

    3: Lancez votre propre fonction similaire à lexical_cast qui vérifie la conversion et renvoie true/false selon si elle est réussie ou pas. Cela ne peut fonctionner que dans le cas 1 & 2 ne correspond pas à vos exigences.

    • Pick A. Regex ne vais pas vous dire s'il déborde la portée d'un nombre entier.
    • Ah, oui, oublié de débordement, bah, va frapper que.
    • Question d'origine ne mentionne pas vouloir vérifier pour les dépassements ou même vouloir utiliser un nombre comme un entier. Pour tous, je voudrais savoir, ils sont la planification sur le maintien du nombre en une chaîne de caractères afin d'éviter de telles limites.
    • Bon, j'ai essayé de changer la réponse à inclure les 3 options que j'avais initialement répertoriés, avec une raison pour chacun d'eux.
    InformationsquelleAutor Jacob
  8. 1
    template <typename T>
const T to(const string& sval)
{
        T val;
        stringstream ss;
        ss << sval;
        ss >> val;
        if(ss.fail())
                throw runtime_error((string)typeid(T).name() + " type wanted: " + sval);
        return val;
}

    Et puis vous pouvez l'utiliser comme ça:

    double d = to<double>("4.3");

    ou

    int i = to<int>("4123");
    • Je préfère utiliser boost::lexical_cast.
    • Donc l'exemple d'origine.
    InformationsquelleAutor Nicolas Viennot
  9. 1

    J'ai modifié paercebal de la méthode pour répondre à mes besoins:

    typedef std::string String;    

bool isInt(const String& s, int base){
   if(s.empty() || std::isspace(s[0])) return false ;
   char * p ;
   strtol(s.c_str(), &p, base) ;
   return (*p == 0) ;
}


bool isPositiveInt(const String& s, int base){
   if(s.empty() || std::isspace(s[0]) || s[0]=='-') return false ;
   char * p ;
   strtol(s.c_str(), &p, base) ;
   return (*p == 0) ;
}


bool isNegativeInt(const String& s, int base){
   if(s.empty() || std::isspace(s[0]) || s[0]!='-') return false ;
   char * p ;
   strtol(s.c_str(), &p, base) ;
   return (*p == 0) ;
}

    Remarque:

    1. Vous pouvez vérifier les différentes bases (binaire, oct, hex et autres)
    2. Faire sûr vous ne passez pas 1, négatif ou la valeur >36 comme base.
    3. Si vous passez 0 comme la base, il va détecter automatiquement la base je.e pour une chaîne commençant par 0x seront traités comme hex et chaîne commençant par 0 seront traités comme des oct. Les personnages sont insensibles à la casse.
    4. Tout espace blanc dans la chaîne de rendre renvoyer false.
    InformationsquelleAutor Jahid
  10. 1

    Ici est une autre solution.

    try
{
  (void) std::stoi(myString); //cast to void to ignore the return value   
  //Success! myString contained an integer
} 
catch (const std::logic_error &e)
{   
  //Failure! myString did not contain an integer
}
    • Les Exceptions ne devraient pas être utilisés pour les opérations normales et le contrôle de flux. Ils devraient seulement être utilisés pour... vous l'avez deviné: les exceptions. 😉
    • Merci pour les commentaires!
    InformationsquelleAutor Benjamin