Wie lösche ich die Standardeingabe, bevor ich eine neue Eingabe erhalte?

Question

Ich habe ungefähr 5-10 verschiedene Ratschläge gelesen, wie man Stdin löscht, aber keiner von ihnen passt zu meinen Bedürfnissen. Die Sache ist, dass fflush(stdin) perfekt an meinem Computer funktioniert, aber leider scheint es nicht überall zu funktionieren, also brauche ich etwas mit der gleichen Funktionalität. Jede andere Art, die ich versuchte, löscht Stdin, wenn es nicht leer ist, aber erfordert Benutzereingaben, wenn stdin leer ist, was bedeutet, dass es Eingaben in einem Moment benötigt, den ich nicht bekommen möchte (+ es wirft es trotzdem ab).

Die Frage ist: Kann ich irgendwie sicherstellen, dass stdin IS leer ist, bevor ich Benutzereingaben benötige? (Und wenn nicht, dann und nur dann klar, dass es irgendwie?) so etwas wie:

if (stdin is NOT empty) 
    while (getchar() != '\n') 
     continue; 

EDIT: die Sache ist, dass ich Zeichen laden von stdin eins nach dem anderen und irgendwann, einen Teil der Eingabe von vorherige Iteration könnte oder wird nicht verworfen. So oder so, ich brauche clear stdin, bevor ich den Benutzer für eine andere Eingabe, die verarbeitet werden soll. Das Löschen des Puffers selbst ist keine so große Sache, das Problem ist, was passiert, wenn die Eingabe leer ist, wenn das Programm zum Löschen stdin kommt, weil das Programm in diesem Moment eine andere Eingabe benötigt, die von der Reinigung aufgefressen wird Funktion. Das will ich loswerden. (Wenn ich fflush(stdin); verwenden kann ich wusste nur, dass für die nächste Zeile meines Programms der stdin leer sein wird, egal was, keine Fragen gestellt ...)

Answer 1

TL; DRfflush(stdin) Invokes undefined behavior gemäß der Norm Du solltest es niemals benutzen.

---

, um Ihren Code Coming (Logik), anstatt für eine neue Zeile zu suchen, können Sie für EOF suchen. Es ist nicht erforderlich, dass stdineinige Eingang vor dem Ausführen dieser Schleife haben sollte.

So etwas wie

while (getchar() != EOF); //; is not a mistake 

sollten Ihre Bedürfnisse erfüllen.

Answer 2

Verwenden Sie nurfgets(), um stdin zu lesen.

Verwenden Sie einen Puffer, der groß genug ist, und/oder testen Sie ihn auf volle Zeilen.

Mit fgets() müssen Sie sich nie um zusätzliche Zeichen in stdin kümmern.

// read characters until 'X' 
while (((ch = getchar()) != EOF) && (ch != 'X')) putchar(ch); 
// discard X and the rest of the line 
fflush(stdin); // UB except for Windows 

---

// read full line 
char tmp[1000], *p; 
if (!fgets(tmp, sizeof tmp, stdin)) /* deal with error */; 
if (!*tmp) /* embedded NUL detected: input is not a text file */; 
if (tmp[strlen(tmp) - 1] != '\n') /* partial line */; 
p = tmp; 
while (*p && *p != 'X') putchar(*p++); 
// ignore the X and all the subsequent characters 

Answer 3

Das select Modul bietet eine Funktion select genannt, die genau das, was Sie suchen erreicht. select.select hat drei Argumente:

select.select(rlist, wlist, xlist) 

Jedes Argument eine Liste von Datei-Deskriptoren (wie [sys.sdtin]) sein sollte, und es wartet dann, bis ein bestimmte IO-Betrieb zur Verfügung steht.Die IO-Operationen sind r ead, w rite oder einige andere e x ception auf den angegebenen Dateideskriptoren. Es gibt tuple der entsprechenden Listen zurück, die mit den Dateideskriptoren gefüllt sind, die bereit sind.

Also, wenn es Eingang in sys.stdin wartet dann würde die Funktion wie so verhalten:

>>> import select 
>>> import sys 
>>> 
>>> select.select([sys.stdin], [], []) 
([sys.stdin], [], []) 
>>> 

Von selbst, das löst nicht das Problem, da standardmäßig wird die Funktion warten, bis ein IO-Betrieb verfügbar. Wichtig ist jedoch, select.select hat ein optionales timeout Argument, das angibt, wie lange es warten wird, bevor es aufgibt. Wir müssen das Timeout einfach auf Null setzen und können nach Eingaben suchen, ohne den Programmablauf zu blockieren.

Nehmen wir ein Beispiel sehen, wo es keinen Eingang in sys.stdin wartet:

>>> import select 
>>> import sys 
>>> 
>>> timeout = 0 
>>> select.select([sys.stdin], [], [], timeout) 
([], [], []) 
>>> 

Zu wissen, dass wir nur das erste Element dieses Tupel wollen (die Eingangsströme) wir sind bereit, ein sinnvoll, wenn Aussage zu machen :

if sys.stdin in select.select([sys.stdin], [], [], 0)[0]: 
    print('Input is waiting to be read.') 

, dass der Eingangsstrom braucht nur etwas Iteration bedeutet Clearing:

while sys.stdin in select.select([sys.stdin], [], [], 0)[0]: 
    sys.stdin.readline() 

Und wir können dies natürlich auf jedem Eingangsstrom verwenden, läßt es so setzt in einer Funktion:

def clear_input(stream, timeout=0): 
    '''Takes an input stream and discards each line in the buffer. 
    The given timeout denotes how long in seconds to wait for 
    further input when none is available. 
    ''' 
    while stream in select.select([stream], [], [], timeout)[0]: 
     stream.readline() 

Also lassen Sie sich unsere Funktion demonstrieren zu erreichen, was Sie in Ihrer Frage stellen:

import select 
import sys 
import time 

def clear_input(stream, timeout=0): 
    while stream in select.select([stream], [], [], timeout)[0]: 
     stream.readline() 

if __name__ == '__main__': 
    print('Type some lines now. They will be ignored.') 
    time.sleep(5) 

    print('Clearing input.') 
    clear_input(sys.stdin) 

    user_input = raw_input('Please give some fresh input: ') 
    print(user_input) 

Die clear_input-Funktion kann als blockierungsfreie Möglichkeit zum Löschen von Eingabeströmen verwendet werden und sollte in Python2 und Python3 funktionieren.

Answer 4

Wie kann ich die Standardeingabe löschen, bevor ich eine neue Eingabe erhalte?
.. also brauche ich etwas mit der gleichen Funktionalität.

Mit tragbaren C ist dies nicht möglich.

---

vorschlagen stattdessen ein anderes (und mehr üblich C) Paradigma: Versichern vorherige Eingabefunktionen all die vorherige Eingabe verbrauchen.

fgets() (oder * nix getline()) ist der typische Ansatz und löst die meisten Situationen.

Oder rollen Sie Ihre eigenen. Folgendes verbraucht, speichert jedoch keine zusätzlichen Eingaben.

int mygetline(char *buf, size_t size) { 
    assert(size > 0 && size < INT_MAX); 
    size_t i = 0; 
    int ch; 
    while ((ch = fgetc(stdin)) != EOF) { 
    if (i + 1 < size) { 
     buf[i++] = ch; 
    } 
    if (ch == '\n') { 
     break; 
    } 
    } 
    buf[i] = '\0'; 
    if (i == 0) { 
    return EOF; 
    } 
    return i; 
}