C++: comment puis-je enlever la mauvaise entrée de cin?

J'ai fait quelques cin de fonctionnement et d'avant-je utiliser cin je veux effacer son état et
le rincer. Comment dois-je faire? Je sais cin.clear() efface l'erreur de l'état, mais pour vider le cin
tampon comment puis-je vérifier si il est vide et si pas qui des déclarations ci-dessous doit-je utiliser pour le vider afin que je puisse utiliser en toute sécurité cin plus tard?

cin.ignore(std::numeric_limits<std::streamsize>::max());

cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

merci de voir gidforums.com/t-15686.html pour un aperçu général (d'abord répondre à l'OP)

OriginalL'auteur ajay | 2013-10-19

c++iostream

5

Il semble, vous avez détecté un problème et que vous voulez vous débarrasser de faux entrée, par exemple, l'entrée ligne. Vous pourrait essayer de se débarrasser de ce std::cin a dans sa mémoire tampon, mais généralement, cela ne fonctionne pas trop bien car il n'y a aucune garantie que le flux a lire, par exemple, une ligne complète. Aussi, pour le rendre potentiellement utiles dont vous aurez besoin pour vous assurer que stdin et std::cin ne sont pas synchronisés autrement std::cin ne sera jamais de la mémoire tampon de tous les caractères de toute façon:
```
std::ios_base::sync_with_stdio(false);
//read data using std::cin

if (!std::cin) {
    //clean-up
    std::cin.clear();
    if (std::cin) {
        std::cin.ignore(std::cin.rdbuf()->in_avail()); //ignore what is buffered
    }
}
```
Si in_avail() renverra une valeur différente de zéro dépend entièrement de l'utilisé de la mémoire tampon, et il peut ignorer plus que vous avez réellement envie de les ignorer, de toute façon. Par exemple, si std::cin's de la mémoire tampon est remplacé à l'utilisation de la mémoire tampon du flux d'un std::istringstream il sera probablement consommer tout le caractère de cette source.

Probablement le plus sensible de nettoyage est à ignore() le caractère suivant ou les caractères sur la ligne courante, à l'aide
```
std::cin.ignore();
```
ou
```
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
```
La max() de std::streamsize est utilisé comme un nombre magique pour indiquer que le compte ne doit pas être considérée comme un licenciement critères. Si vous ne passez pas d'un caractère de fin le flux ignorer les caractères jusqu'à la fin du cours d'eau qui n'est probablement pas ce que vous voulez.

si je ne passe pas un caractère de fin puis après effacement de la mémoire tampon, il n'est pas passer à l'instruction suivante, au lieu de cela, il demande des informations d'entrée jusqu'à ce que je entrer EOF par ctrl+d
bien sûr: les conditions de résiliation pour ignore() sont: 1. il a lu autant de caractères comme indiqué par le premier argument (par défaut 1); 2. le caractère de fin a été conumed (par défaut std::char_traits<char>::eof() qui indique qu'aucun caractère ne doit être assortie); 3. la fin du flux est atteinte. La spécification de std::numeric_limits<std::streamsize>::max() rend le comptage à l'infini et ne pas spécifier de résiliation caractères provoque le flux ne jamais s'arrêter en raison d'un personnage, c'est à dire, il ne s'arrêtera qu'une fois que le flux est consommé.
désolé, mais juste pour éclaircir mes doutes, à la fin du flux est atteinte lorsque EOF est rencontré?
EOF == Fin De Fichier, qui est le terme conventionnel pour atteindre l'entrée. Notez, cependant, que les flux ne sont pas nécessairement rencontre C EOF mais plutôt std::char_traits<cT>::eof(): cette valeur est utilisée comme un indicateur d'erreur en fonction retournant un cT (qui est juste char pour les ruisseaux étroits) quand il n'y a pas de personnage.

OriginalL'auteur Dietmar Kühl

Flux tampons ont la in_avail méthode. Mais essayez tout simplement de supprimer le contenu indépendamment.:

template <class charT, class traits>
std::basic_istream<charT, traits>&
empty_buffer(std::basic_istream<charT, traits>& is)
{
    std::basic_streambuf<charT, traits>* p = is.rdbuf();
    p->pubseekpos(0, std::ios_base::in);

    return is.ignore(std::numeric_limits<std::streamsize>::max());
}

OriginalL'auteur 0x499602D2

Effectivement, cela peut être fait avec la méthode is_avail().
Essayez ceci:

#include <iostream>

int empty_stream(std::istream & is) {

    std::streambuf * pbuf = std::cin.rdbuf();
    std::streamsize size = pbuf->in_avail();

    if(size)
    {
        if(!is.good())
            return 0;
        is.sync();
        return 1;
    }
    else
        return -1;
}

int main() {

    char str[50];

    std::cin >> str;

    switch(empty_stream(std::cin))
    {
    case -1:
        std::cout << "Empty buffer" << std::endl;
        break;
    case 0:
        std::cout << "Error flags in stream" << std::endl;
        break;
    case 1:
        std::cout << "Buffer flushed" << std::endl;
        break;
    }

    std::cin.get(); //This shouldn't be bypassed

    return 0;
}

OriginalL'auteur DarzVader

Vous devez vous connecter pour publier un commentaire.