Peek an Eingangspuffer, und spülen zusätzliche Zeichen in C

Question

Wenn ich einen einen Zeicheneingabe in C erhalten möchten, wie würde ich prüfen, ob zusätzliche Zeichen gesendet wurden, und wenn ja, wie würde ich das klar?

Gibt es eine Funktion, die wie getc wirkt (stdin), die aber nicht aufgefordert, den Benutzer ein Zeichen einzugeben, so kann ich nur while(getc(stdin)!=EOF); setzen? Oder eine Funktion bei der nächsten Zeichen im Puffer spähen, und wenn es nicht NULL zurückgibt (oder was auch immer wäre es), konnte ich rufen eine (weitere) Funktion, die stdin spült?

Bearbeiten

jetzt So scheint scanf den Trick zu tun, aber ist es eine Möglichkeit, um es das ganze string, bis zum Newline zu lesen? Anstatt zum nächsten Leerzeichen? Ich weiß, ich kann nur „% s% s% s“ setzen oder was auch immer in das String-Format, aber kann ich umgehen, eine beliebige Anzahl von Räumen?

Answer 1

Sie können den Eingangsstrom nicht spülen. Sie werden den Aufruf nicht definiertes Verhalten, wenn Sie tun. Ihre beste Wette ist zu tun:

int main() {
  int c = getchar();
  while (getchar() != EOF);
  return 0;
}

scanf Magie zu benutzen:

#include <stdio.h>
#include <stdlib.h> 

#define str(s) #s
#define xstr(s) str(s)
#define BUFSZ 256

int main() {
  char buf[ BUFSZ + 1 ];
  int rc = scanf("%" xstr(BUFSZ) "[^\n]%*[^\n]", buf);
  if (!feof(stdin)) {
    getchar();
  }
  while (rc == 1) {
    printf("Your string is: %s\n", array);
    fflush(stdout);
    rc = scanf("%" xstr(LENGTH) "[^\n]%*[^\n]", array);
    if (!feof(stdin)) {
        getchar();
    }
   }
   return 0;
}

Answer 2

Sie können getline verwenden, um eine ganze Zeile der Eingabe zu lesen.

Alternativ (als Antwort auf Ihre ursprüngliche Frage) Sie select oder poll auf stdin anrufen können, um zu sehen, ob es weitere Zeichen gelesen werden.

Answer 3

Ich hatte ein ähnliches Problem heute, und ich habe einen Weg gefunden, die zu funktionieren scheint. Ich weiß nicht, die Details Ihrer Situation, so dass ich weiß nicht, ob es für Sie arbeitet oder nicht.

Ich schreibe eine Routine, die ein einzelnes Zeichen von der Tastatur bekommen muss, und es muss ein von drei bestimmten Tastenanschlägen (a ‚1‘, ein ‚2‘ oder ein ‚3‘) sein. Wenn es nicht einer von denen ist, muss das Programm senden und zu Fehlermeldung und Schleife zurück für einen anderen Versuch.

Das Problem ist, dass zusätzlich zu dem Charakter, den ich von getchar zurück eintreten wird (), ‚Enter‘ Tastendruck (die den Tastendruck, um das Programm sendet) wird in einem Eingangspuffer gespeichert. Das (nicht-druckende) Neue-Zeile-Zeichen wird dann durch die getchar () Einrichtung in der Fehlerkorrekturschleife zurückzugeführt, was in einer zweiten Fehlermeldung (da das Neue-Zeile-Zeichen, das nicht entweder ein ‚1‘ ist, a ‚2‘ , noch ein '3').

Das Problem wird noch komplizierter, weil ich manchmal vor mir selbst bekommen und stattdessen ein einzelnes Zeichen einzugeben, werde ich die Dateinamen eingeben, dass eine dieser Optionen anfordert. Dann habe ich eine ganze Reihe von unerwünschten Zeichen in dem Puffer, was zu einer langen Liste von Fehlermeldungen nach unten scrollen Sie den Bildschirm.

Nicht cool.

Was es behoben zu haben scheint, obwohl, ist die folgende:

c = getchar();  // get first char in line
while(getchar() != '\n') ; // discard rest of buffer

Die erste Zeile ist derjenige, der den Charakter tatsächlich nutzt ich ein. Die zweite Leitung verfügt über was auch immer Rest verbleibt in dem Eingangspuffer. Es schafft einfach eine Schleife, die um ein Zeichen zu einer Zeit aus dem Eingangspuffer zieht. Es gibt keine Aktion angegeben Platz zu nehmen, während die Anweisung Looping wird. Er liest einfach ein Zeichen, und wenn es kein Newline ist, geht zurück auf die nächste. Wenn es eine neue Zeile findet, endet die Schleife und es geht weiter zum nächsten Punkt der Tagesordnung im Programm.

Answer 4

Wir können eine Funktion machen den Tastaturpuffer zu löschen, wie folgt aus:

#include <stdio.h>

void clear_buffer(){
   char b;
   //this loop take character by character in the keyboard buffer using 
   //getchar() function, it stop when the variable "b" was
   //enter key or EOF.
   while (((b = getchar()) != '\n') && (b != EOF));
}

int main()
{
    char input;
    //get the input. supposed to be one char!
    scanf("%c", &input); 
    //call the clearing function that clear the buffer of the keyboard 
    clear_buffer(); 
    printf("%c\n",input); //print out the first character input
    // to make sure that our function work fine, we have to get the
    // input into the "input" char variable one more time
    scanf("%c", &input); 
    clear_buffer();  
    printf("%c\n",input);
    return 0;
}

Answer 5

Verwenden Sie eine Lese, die eine Menge von Zeichen nehmen (mehr als 1, vielleicht 256), und sehen, wie viele tatsächlich zurückgegeben. Wenn Sie mehr als eins zu bekommen, wissen Sie; wenn Sie nur einen bekommen, das ist alles, was es gab.

Sie erwähnen nicht, Plattform, und das wird ganz ganz schnell schwierig. Zum Beispiel auf Unix (Linux), wird der normale Mechanismus eine Reihe von Daten zurück - wahrscheinlich das ein Zeichen, das Sie nach und eine neue Zeile waren. Vielleicht überzeugen Sie Ihren Benutzer ^ D (default) geben Sie die vorhergehenden Zeichen zu senden. Oder vielleicht haben Sie Steuerungsfunktionen nutzen das Terminal in Raw-Modus zu setzen (wie Programme wie vi und emacs tun).

Unter Windows, ich bin nicht so sicher - ich denke, es ist eine getch() Funktion das tut, was Sie brauchen,

.

Answer 6

Warum Sie scanf nicht statt getc verwenden, durch scanf mit u kann die gesamte Zeichenfolge erhalten.