Wie lösche ich den Eingabepuffer in C?

Ich habe folgendes Programm:

int main(int argc, char *argv[])
{
  char ch1, ch2;
  printf("Input the first character:"); // Line 1
  scanf("%c", &ch1); 
  printf("Input the second character:"); // Line 2
  ch2 = getchar();

  printf("ch1=%c, ASCII code = %d\n", ch1, ch1);
  printf("ch2=%c, ASCII code = %d\n", ch2, ch2);

  system("PAUSE");  
  return 0;
}

Wie der Autor des obigen Codes erklärt hat: Das Programm funktioniert nicht richtig, da es in Zeile 1, wenn der Benutzer die Eingabetaste drückt, im Eingabepuffer 2 Zeichen belässt: Enter key (ASCII code 13)und \n (ASCII code 10). Daher liest es in Zeile 2 das \nund wartet nicht darauf, dass der Benutzer ein Zeichen eingibt.

OK, ich habe das verstanden. Aber meine erste Frage ist: Warum liest die zweite getchar()( ch2 = getchar();) nicht das Zeichen Enter key (13), sondern \ndas?

Als nächstes schlug der Autor zwei Möglichkeiten vor, um solche Probleme zu lösen:

1. verwenden fflush()

2. schreibe eine Funktion wie diese:

   void
   clear (void)
   {    
     while ( getchar() != '\n' );
   }

Dieser Code hat tatsächlich funktioniert. Aber ich kann mir nicht erklären, wie es funktioniert? Weil in der while-Anweisung, die wir verwenden getchar() != '\n', bedeutet dies, dass Sie ein einzelnes Zeichen außer '\n'? wenn ja, bleibt im eingabepuffer noch das '\n'zeichen?

Das Programm funktioniert nicht ordnungsgemäß, da in Zeile 1, wenn der Benutzer die Eingabetaste drückt, im Eingabepuffer 2 Zeichen verbleiben: Eingabetaste (ASCII-Code 13) und \ n (ASCII-Code 10). Daher liest es in Zeile 2 das \ n und wartet nicht darauf, dass der Benutzer ein Zeichen eingibt.

Das Verhalten in Zeile 2 ist korrekt, aber das ist nicht ganz die richtige Erklärung. Bei Streams im Textmodus spielt es keine Rolle, welche Zeilenenden Ihre Plattform verwendet (ob Wagenrücklauf (0x0D) + Zeilenvorschub (0x0A), ein bloßer CR oder ein bloßer LF). Die C-Laufzeitbibliothek erledigt das für Sie: Ihr Programm sieht nur'\n' erledigt Zeilenumbrüche.

Wenn Sie ein Zeichen eingegeben und die Eingabetaste gedrückt haben, wird dieses Eingabezeichen in Zeile 1 und dann '\n'in Zeile 2 gelesen. Siehe Ich verwende scanf %czum Lesen einer J / N-Antwort, aber die spätere Eingabe wird übersprungen. aus den häufig gestellten Fragen zu comp.lang.c.

Informationen zu den vorgeschlagenen Lösungen finden Sie (erneut in den häufig gestellten Fragen zu comp.lang.c):

• Wie kann ich ausstehende Eingaben löschen, damit der Typkopf eines Benutzers bei der nächsten Eingabeaufforderung nicht gelesen wird? Wird fflush(stdin)funktionieren?
• fflushWas kann ich verwenden, um Eingaben zu leeren, wenn dies nicht funktioniert?

die im Grunde sagen, dass der einzige tragbare Ansatz zu tun ist:

int c;
while ((c = getchar()) != '\n' && c != EOF) { }

Ihre getchar() != '\n'Schleife funktioniert, da nach dem Aufruf getchar()das zurückgegebene Zeichen bereits aus dem Eingabestream entfernt wurde.

Außerdem fühle ich mich verpflichtet, Sie davon abzuhalten, scanfganz zu verwenden: Warum sagen alle, nicht zu verwenden scanf? Was soll ich stattdessen verwenden?

Sie können es (auch) so machen:

fseek(stdin,0,SEEK_END);

Eine tragbare Methode zum Löschen bis zum Ende einer Zeile, die Sie bereits teilweise gelesen haben, ist:

int c;

while ( (c = getchar()) != '\n' && c != EOF ) { }

Dies liest und verwirft Zeichen, bis es \ndas Ende der Datei signalisiert. Es wird auch geprüft, EOFob der Eingabestream vor dem Zeilenende geschlossen wird. Der Typ von cmuss int(oder größer) sein, um den Wert halten zu können EOF.

Es gibt keine tragbare Möglichkeit, um herauszufinden, ob nach der aktuellen Zeile weitere Zeilen vorhanden sind (wenn dies nicht der Fall ist, getcharwird die Eingabe blockiert).

Die Linien:

int ch;
while ((ch = getchar()) != '\n' && ch != EOF)
    ;

liest nicht nur die Zeichen vor dem Zeilenvorschub ( '\n'). Es liest alle Zeichen im Stream (und verwirft sie) bis einschließlich des nächsten Zeilenvorschubs (oder EOF wird angetroffen). Damit der Test wahr ist, muss zuerst der Zeilenvorschub gelesen werden. Wenn die Schleife stoppt, war der Zeilenvorschub das letzte gelesene Zeichen, aber es wurde gelesen.

Der Grund, warum ein Zeilenvorschub anstelle eines Wagenrücklaufs gelesen wird, liegt daran, dass das System den Zeilenvorschub in einen Zeilenvorschub übersetzt hat. Wenn die Eingabetaste gedrückt wird, signalisiert dies das Zeilenende ... aber der Stream enthält stattdessen einen Zeilenvorschub, da dies die normale Zeilenende-Markierung für das System ist. Das könnte plattformabhängig sein.

Die Verwendung fflush()in einem Eingabestream funktioniert nicht auf allen Plattformen. Zum Beispiel funktioniert es im Allgemeinen nicht unter Linux.

Aber ich kann mir nicht erklären, wie es funktioniert? Weil wir in der while-Anweisung getchar() != '\n'ein einzelnes Zeichen außer '\n'?? lesen. wenn ja, bleibt im eingabepuffer noch das '\n'zeichen ??? Verstehe ich etwas falsch?

Möglicherweise stellen Sie nicht fest, dass der Vergleich erfolgt, nachdem getchar() das Zeichen aus dem Eingabepuffer entfernt wurde. Also , wenn Sie das erreichen '\n', ist es verbraucht und dann brechen Sie aus der Schleife heraus.

Du kannst es versuchen

scanf("%c%*c", &ch1);

Dabei akzeptiert% * c die neue Zeile und ignoriert sie

eine weitere Methode anstelle von fflush (stdin), die undefiniertes Verhalten aufruft, das Sie schreiben können

while((getchar())!='\n');

Vergessen Sie nicht das Semikolon nach der while-Schleife

unsigned char a=0;
if(kbhit()){
    a=getch();
    while(kbhit())
        getch();
}
cout<<hex<<(static_cast<unsigned int:->(a) & 0xFF)<<endl;

-oder-

benutze vielleicht benutze _getch_nolock().. ???

Beim Versuch, die Lösung zu implementieren, tritt ein Problem auf

while ((c = getchar()) != '\n' && c != EOF) { }

Ich poste eine kleine Anpassung 'Code B' für alle, die vielleicht das gleiche Problem haben.

Das Problem war, dass ich mit dem Programm das Zeichen '\ n' unabhängig vom Eingabezeichen abfing. Hier ist der Code, der mir das Problem gab.

Code A.

int y;

printf("\nGive any alphabetic character in lowercase: ");
while( (y = getchar()) != '\n' && y != EOF){
   continue;
}
printf("\n%c\n", toupper(y));

und die Anpassung bestand darin, das (n-1) -Zeichen kurz vor der Auswertung der Bedingung in der while-Schleife zu "fangen". Hier ist der Code:

Code B.

int y, x;

printf("\nGive any alphabetic character in lowercase: ");
while( (y = getchar()) != '\n' && y != EOF){
   x = y;
}
printf("\n%c\n", toupper(x));

Die mögliche Erklärung ist, dass die while-Schleife, um zu unterbrechen, der Variablen y den Wert '\ n' zuweisen muss, damit sie der zuletzt zugewiesene Wert ist.

Wenn ich etwas mit der Erklärung, Code A oder Code B verpasst habe, sag mir bitte, ich bin kaum neu in c.

hoffe es hilft jemandem

Eine andere noch nicht erwähnte Lösung ist die Verwendung von: Rücklauf (stdin);

Versuche dies:

stdin->_IO_read_ptr = stdin->_IO_read_end;

Kurz, tragbar und in stdio.h deklariert

stdin = freopen(NULL,"r",stdin);

Wird nicht in einer Endlosschleife aufgehängt, wenn auf stdin nichts zu spülen ist, wie in der folgenden bekannten Zeile:

while ((c = getchar()) != '\n' && c != EOF) { }

Ein wenig teuer, verwenden Sie es also nicht in einem Programm, das den Puffer wiederholt löschen muss.

Von einem Kollegen gestohlen :)