entier de validation de la saisie, comment?

Je vais avoir un problème avec ce que devrait être incroyablement simple code. Je veux prendre un nombre entier compris entre 1 et 3 avec la vérification des erreurs. Il fonctionne très bien pour la vérification des numéros qui sont trop gros ou trop petit, mais quand une alpha/nombre de combinaison est entré, il est coincé dans une boucle infinie. Des Suggestions?

#include <iostream>
using namespace std;

int main(int argc, char *argv[]){
    int input;

    cout << "\nPlease enter a number from 1 to 3:" << endl;
    cout << "-> ";
    cin >> input;

    while(input< 1 || input> 3){
        cout << "\n---------------------------------------" << endl;
        cout << "\n[!] The number you entered was invalid." << endl;
        cout << "\nPlease re-enter a number from 1 to 3" << endl;
        cout << "-> ";
        cin >> input;
    }

    cout << "You chose " << input << endl;
}
Lire string et stackoverflow.com/questions/2844817/... et stackoverflow.com/questions/7021725/...

OriginalL'auteur Rick_Sch | 2012-11-03

  1. 7

    Le problème est que:

    cin >> input;

    Sera la cause de la mauvaise bits lorsque vous essayez de lire une non valeur numérique. Après cela toute tentative d'utilisation de la operator>> est ignoré en silence.

    De sorte que le moyen de corriger cela est de tester si le flux est en bon état et si non, alors réinitialiser les indicateurs de l'état et d'essayer de la lire à nouveau. Mais notez que le mauvais d'entrée (à l'origine du problème) est toujours à l'entrée de sorte que vous devez assurez-vous de jeter ainsi.

    if (cin >> input)
{
    //It worked (input is now in a good state)
}
else
{
    //input is in a bad state.
    //So first clear the state.
    cin.clear();

    //Now you must get rid of the bad input.
    //Personally I would just ignore the rest of the line
    cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

    //now that you have reset the stream you can go back and try and read again.
}

    Pour l'empêcher de rester coincé (ce qui est causé par le mauvais bits définis) lire en une chaîne de caractères, puis utiliser une chaîne de stream pour analyser la saisie de l'utilisateur. Je préfère aussi cette méthode (pour l'utilisateur interactif d'entrée), car elle permet de faciliter la combinaison de différents styles de lecture (c'est à dire combinant operator>> et std::getline() que vous pouvez les utiliser sur les stringstream).

    #include <iostream>
#include <sstream>
#include <string>
//using namespace std;
//Try to stop using this.
//For anything other than a toy program it becomes a problem.

int main(int argc, char *argv[])
{
    int          input;

    std::string  line;
    while(std::getline(std::cin, line))   //read a line at a time for parsing.
    {
        std::stringstream linestream(line);
        if (!(linestream >> input))
        {
             //input was not a number
             //Error message and try again
             continue;
        }
        if ((input < 1) || (input > 3))
        {
             //Error out of range
             //Message and try again
             continue;
        }
        char errorTest;
        if (linestream >> errorTest)
        {
             //There was extra stuff on the same line.
             //ie sobody typed 2x<enter>
             //Error Message;
             continue;
        }

        //it worked perfectly.
        //The value is now in input.
        //So break out of the loop. 
        break;
    }
}
    Fixe. Mais vous pourriez avoir fixé pour moi.
    Je ne serais pas d'accord. Lire: Pourquoi le “using namespace std;” considéré comme une mauvaise pratique? L'utilisation de construire est un problème dans la plupart des situations et conduit à l'introduction de bugs lorsque vous maintenez le code qui sont difficiles à repérer et diagnostiquer.
    Je suis conscient de tous les problèmes que cela peut entraîner, mais ces problèmes sont limités à l'intérieur d'un rpc fichier source si vous continuez à la section "utilisation" des trucs en dehors de tout fichier d'en-tête. Encore, cela peut conduire à des problèmes, mais dans le code de l'OP, il serait inutile d'être totalement explicite.
    une autre chose est, par exemple, de using Foo::A; et puis, vous ajoutez using Bar::A, il est facile de reconnaître que vous êtes de prendre deux de classe avec le même nom, accessible dans le même champ d'application. La plupart du temps, vous aurez à votre using lignes à la même place dans votre rpc, rendant possibles des erreurs faciles à corriger. Ne jamais utiliser using namespace A; et using namespace B;, avec deux espaces de noms entièrement accessible comme ça, d'avoir des ennuis. Je vais vous donner la point encore, il vaut mieux éviter si vous ne connaissez pas le risque.
    Merci. Fixe.

    OriginalL'auteur Martin York

  2. 2
    #include <iostream>
#include <string>

using namespace std;

int validatedInput(int min = 1, int max = 3)
{
    while(true)
    {
        cout << "Enter a number: ";
        string s;
        getline(cin,s);
        char *endp = 0;
        int ret = strtol(s.c_str(),&endp,10);
        if(endp!=s.c_str() && !*endp && ret >= min && ret <= max)
            return ret;
        cout << "Invalid input. Allowed range: " << min << "-" << max <<endl;
    }
}

int main(int argc, char *argv[])
{
    int val = validatedInput();
    cout << "You entered " << val <<endl;
    return 0;
}
    vous avez oublié de #include <stdlib.h> pour strtol
    hmm fonctionne pour moi, même sans l'inclusion. mais je pense que cela pourrait être le moindre de ses problèmes 😉
    strtol - nouveau compilateur voudrais vous dire ceci.

    OriginalL'auteur pokey909

  3. 1

    La plupart de ces réponses comprennent la complexité inutile.

    Entrée de validation est un moment idéal pour utiliser un faire-lors de la

    do{

   cout << "\nPlease enter a number from 1 to 3:" << endl;
   cout << "-> ";

   if(!cin){
      cout << "Invalid input"
      cin.clear()
      cin.ignore(numeric_limits<streamsize>::max(), '\n');
   }

}while(!(cin >> input))

    • Utilisation numeric_limits<streamsize>::max() complètement clair la
      tampon après l'échec d'une cin.

    • Utilisation cin.clear() pour réinitialiser l'échec de drapeau sur cin donc !cin habitude
      évaluez toujours faux.

    cin.fail() est très bien. Toutefois, certains considèrent !cin plus naturel.

    de mon post précédent https://stackoverflow.com/a/43421325/5890809

    OriginalL'auteur Shan L

  4. 0

    Vous avez déclaré d'entrée en tant que int mais quand vous écrivez un caractère alphanumérique pour la saisie, elle va essayer de convertir implicitement en entier. Mais vous la vérification des erreurs à ne pas tenir compte de cela.

    Ur problème peut être facilement résolu par un changement dans la boucle while. au lieu de vérifier ce que diriez-vous de vérifier

    while(input!=1 || input!=2 || input!=3)
    Malheureusement pas. Le flux est dans un mauvais état. Vous avez besoin de réinitialiser les indicateurs de l'état avant de tenter à nouveau la lecture.
    Que faire si nous devons vérifier si l'entrée est entre 1 et 12000, ou tout simplement à la validation des entrées de voir que l'utilisateur entre un nombre entier et non alphanumérique charabia?

    OriginalL'auteur RDismyname