Comment puis-je vider le cin tampon?

Comment faire pour effacer le cin tampon en C++?

InformationsquelleAutor | 2008-11-02

95

Éventuellement:
```
std::cin.ignore(INT_MAX);
```
Ce serait de lire et d'ignorer tout jusqu'à ce que EOF. (vous pouvez également fournir un deuxième argument qui est le caractère de lire jusqu' (ex: '\n' d'ignorer une seule ligne).

Aussi: Vous voulez probablement faire un: std::cin.clear(); avant ce trop pour réinitialiser le flux de l'etat.
- (Vieux je sais). Clair avant, plutôt, de sorte que le flux est mis dans un état où il peut travailler sur sa mémoire tampon.
- Merci, GMan! Il l'a fait dans le mauvais sens, d'abord, et passé un certain temps à la recherche de mon erreur.
- juste correction de la réponse.
- La solution la plus évidente je l'ai fait, avec le recul, merci. 🙂
- Je voulais simplement faire remarquer que, pour mon cas, je trouve le '\n' est nécessaire. Sinon les "cin >>" ne fonctionne pas.
- Pour moi cela s'arrête jusqu'à ce qu'il trouve au moins autant de caractères comme argument (compilateur de microsoft)
- bien sûr, cela indique le code d'ignorer TOUS les caractères jusqu'à ce que le montant spécifié. Dans l'exemple principal, il ignore essentiellement jusqu'à ce que EOF (parce que INT_MAX est énorme). Comme mentionné dans le post, si vous voulez juste pour ignorer une seule ligne, vous devez spécifier un paramètre supplémentaire de '\n à dire que vous ne voulez ignorer jusqu'à la fin de la ligne.
- Si vous faites cela, la prochaine fois que vous appelez getline(cin, entrée), vous pouvez appuyer sur un char suivie par entrée tout au long de la journée, il ne sera pas envoyé.
InformationsquelleAutor Evan Teran
109

Je préfère le C++ contraintes de taille sur le C versions:
```
//Ignore to the end of file
cin.ignore(std::numeric_limits<std::streamsize>::max())

//Ignore to the end of line
cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n')
```
- Plus important encore, les valeurs peuvent être différentes! (streamsize n'a pas à être de type int)
- pourriez-vous nous citer un exemple où nous avons besoin de l'ignorer à la fin du fichier car si j'utilise cin et l'utilisation de la première déclaration ci-dessus pour vider le cin tampon, puis il garde une demande d'entrée jusqu'à ce que je entrer EOF en appuyant sur ctrl+d?
- Pas de. C'est quelque chose que vous aurez besoin de décider. Je ne fais qu'expliquer ce que le ci-dessus ne pourra le faire.
InformationsquelleAutor Martin York
23
```
cin.clear();
fflush(stdin);
```
C'était la seule chose qui a fonctionné pour moi lors de la lecture à partir de la console. Dans tous les autres cas, il s'agirait soit de lire indéfiniment en raison de l'absence de \n, ou quelque chose qui restera dans la mémoire tampon.

EDIT:
J'ai trouvé que la solution précédente fait qu'aggraver les choses. Celui-ci cependant, les œuvres:
```
cin.getline(temp, STRLEN);
if (cin.fail()) {
    cin.clear();
    cin.ignore(numeric_limits<streamsize>::max(), '\n');
}
```
InformationsquelleAutor jyggorath
10

J'ai trouvé deux solutions pour cela.

La première, et la plus simple, est d'utiliser std::getline() par exemple:
```
std::getline(std::cin, yourString);
```
... qui va jeter le flux d'entrée quand il arrive à une nouvelle ligne. Lire plus sur cette fonction,ici.

Une autre option que directement rejette le flux est-ce...
```
#include <limits>
//Possibly some other code here
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\n');
```
Bonne chance!

InformationsquelleAutor Ben

int i;
  cout << "Please enter an integer value: ";

  //cin >> i; leaves '\n' among possible other junk in the buffer. 
  //'\n' also happens to be the default delim character for getline() below.
  cin >> i; 
  if (cin.fail()) 
  {
    cout << "\ncin failed - substituting: i=1;\n\n";
    i = 1;
  }
  cin.clear(); cin.ignore(INT_MAX,'\n'); 

  cout << "The value you entered is: " << i << " and its double is " << i*2 << ".\n\n";

  string myString;
  cout << "What's your full name? (spaces inclded) \n";
  getline (cin, myString);
  cout << "\nHello '" << myString << "'.\n\n\n";

InformationsquelleAutor

4

Que je préfère:
```
cin.clear();
fflush(stdin);
```
Il y a un exemple où la cin.ignorer n'est tout simplement pas le couper, mais je ne peux pas penser à ça pour le moment. C'était il y a longtemps quand j'ai eu besoin de l'utiliser (avec Mingw).

Cependant, fflush(stdin) est un comportement non défini selon la norme. fflush() est là que pour les flux de sortie. fflush(stdin) ne semble fonctionner comme prévu sur Windows (avec GCC et MS compilateurs au moins) comme une extension de la norme C.

Donc, si vous l'utilisez, votre code n'est pas portable.

Voir À l'aide de fflush(stdin).

Aussi, voir http://ubuntuforums.org/showpost.php?s=9129c7bd6e5c8fd67eb332126b59b54c&p=452568&postcount=1 pour une alternative.
- fflush(stdin); est un Comportement Indéfini (dans le langage de programmation C), explicitement mentionnés dans 7.18.5.2/2
- +1 pour la fourniture d'un permis de travail bidouille. Certaines personnes ont des emplois d'autres personnes ont des normes.
- Votre travail devrait inclure la rédaction conforme à la norme code. Je ferai en sorte d'éviter d'utiliser tout ce que vous avez écrit dans l'avenir.
InformationsquelleAutor Shadow2531
3

Comment sur:
```
cin.ignore(cin.rdbuf()->in_avail());
```
- le streambuf de in_avail() la fonction n'est pas fiable, et de nombreuses implémentations juste de retour à zéro. Voir: connect.microsoft.com/VisualStudio/feedback/details/509337/... gnu libc++ est similaire
InformationsquelleAutor
3

Un autre possible (manuel) la solution est
```
cin.clear();
while (cin.get() != '\n') 
{
    continue;
}
```
Je ne peux pas utiliser fflush ou cin.flush() avec CLion si cela est arrivé à portée de main.
- boucle infinie pour moi.
- Il fonctionne seulement si il est en fin de ligne, sinon la boucle infinie
InformationsquelleAutor Bobul Mentol
2

Façon la plus simple:
```
cin.seekg(0,ios::end);
cin.clear();
```
Il vient de positions de la cin pointeur à la fin du flux stdin et cin.clear() efface tous les indicateurs d'erreur tels que les expressions du FOLKLORE drapeau.

InformationsquelleAutor Chaitanya Vaishampayan
1

La suivante devrait fonctionner:
```
cin.flush();
```
Sur certains systèmes, il n'est pas disponible et vous pouvez ensuite utiliser:
```
cin.ignore(INT_MAX);
```
- pourquoi écrire manuellement une boucle lorsque vous pouvez dire ignorer le lire INT_MAX caractères jusqu'à ce qu'il atteigne EOF (la valeur par défaut de la deuxième paramètre).
- Gunnar, peut-être mieux d'éditer ton post afin de refléter ce, juste au cas où.
- Aussi loin que je peux dire, le flush méthode est de sortie, et traite déjà écrit caractères.
- cin.flush(): basic_istream<char>' has no member named 'flush'
InformationsquelleAutor Gunnar Steinn
1
```
#include <stdio_ext.h>
```
et ensuite utiliser la fonction
```
__fpurge(stdin)
```
InformationsquelleAutor techcomp
0

cin.get() semble pour le rincer automatiquement curieusement (probablement pas préféré car c'est source de confusion et probablement capricieux).

InformationsquelleAutor GuestPerson001

Vous devez vous connecter pour publier un commentaire.