Come cancellare il buffer di input in C?

Ho il seguente programma:

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;
}

Come ha spiegato l'autore del codice sopra: Il programma non funzionerà correttamente perché alla Riga 1, quando l'utente preme Invio, lascerà nel buffer di input 2 caratteri: Enter key (ASCII code 13)e \n (ASCII code 10). Pertanto, alla riga 2, leggerà \ne non aspetterà che l'utente inserisca un carattere.

OK, ho capito. Ma la mia prima domanda è: perché la seconda getchar()( ch2 = getchar();) non legge il carattere Enter key (13), invece del \ncarattere?

Successivamente, l'autore ha proposto 2 modi per risolvere tali problemi:

1. uso fflush()

2. scrivi una funzione come questa:

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

Questo codice ha funzionato effettivamente. Ma non riesco a spiegarmi come funziona? Perché nell'istruzione while, che usiamo getchar() != '\n', ciò significa leggere un singolo carattere tranne '\n'? in caso affermativo, nel buffer di input rimane ancora il '\n'carattere?

Il programma non funzionerà correttamente perché alla riga 1, quando l'utente preme Invio, lascerà nel buffer di input 2 caratteri: tasto Invio (codice ASCII 13) e \ n (codice ASCII 10). Pertanto, alla riga 2, leggerà \ ne non aspetterà che l'utente inserisca un carattere.

Il comportamento che vedi alla riga 2 è corretto, ma non è proprio la spiegazione corretta. Con i flussi in modalità testo, non importa quali terminazioni di riga utilizza la tua piattaforma (se ritorno a capo (0x0D) + avanzamento riga (0x0A), un semplice CR o un semplice LF). La libreria runtime C si prenderà cura di questo per te: il tuo programma vedrà solo le '\n'nuove righe.

Se si digita un carattere e si preme Invio, il carattere di input verrà letto dalla riga 1 e quindi '\n'dalla riga 2. Vedere Sto usando scanf %cper leggere una risposta S / N, ma l'input successivo viene saltato. dalle FAQ di comp.lang.c.

Per quanto riguarda le soluzioni proposte, vedere (sempre dalla FAQ comp.lang.c):

• Come posso svuotare l'input in sospeso in modo che la testata di un utente non venga letta al prompt successivo? Funzionerà fflush(stdin)?
• Se fflush non funziona, cosa posso usare per scaricare l'input?

che sostanzialmente afferma che l'unico approccio portatile è fare:

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

Il tuo getchar() != '\n' ciclo funziona perché una volta chiamato getchar(), il carattere restituito è già stato rimosso dal flusso di input.

Inoltre, mi sento obbligato a scoraggiarti dall'usare scanfinteramente: perché tutti dicono di non usare scanf? Cosa dovrei usare invece?

Puoi farlo (anche) in questo modo:

fseek(stdin,0,SEEK_END);

Un modo portatile per cancellare fino alla fine di una riga che hai già provato a leggere parzialmente è:

int c;

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

Questo legge e scarta i caratteri finché non ottiene \nche segnala la fine del file. Controlla anche EOFnel caso in cui il flusso di input venga chiuso prima della fine della riga. Il tipo di cdeve essere int(o maggiore) per poter contenere il valore EOF.

Non esiste un modo portatile per scoprire se ci sono altre righe dopo la riga corrente (se non ci sono, getcharbloccherà l'input).

Le linee:

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

non legge solo i caratteri prima dell'avanzamento riga ( '\n'). Legge tutti i caratteri nel flusso (e li scarta) fino a includere successivo avanzamento riga (o viene rilevato EOF) . Affinché il test sia vero, deve prima leggere il linefeed; così quando il ciclo si ferma, il linefeed era l'ultimo carattere letto, ma è stato letto.

Per quanto riguarda il motivo per cui legge un avanzamento riga invece di un ritorno a capo, è perché il sistema ha tradotto il ritorno in un avanzamento riga. Quando si preme Invio, ciò segnala la fine della riga ... ma lo stream contiene invece un avanzamento riga poiché è il normale indicatore di fine riga per il sistema. Potrebbe dipendere dalla piattaforma.

Inoltre, l'utilizzo fflush()su un flusso di input non funziona su tutte le piattaforme; per esempio generalmente non funziona su Linux.

Ma non riesco a spiegarmi come funziona? Perché nell'istruzione while, che usiamo getchar() != '\n', ciò significa leggere ogni singolo carattere tranne '\n'?? in caso affermativo, nel buffer di input rimane ancora il '\n'carattere ??? Sto fraintendendo qualcosa ??

La cosa che potresti non capire è che il confronto avviene dopo aver getchar() rimosso il carattere dal buffer di input. Quindi quando raggiungi il '\n', viene consumato e poi esci dal ciclo.

Puoi provare

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

dove% * c accetta e ignora la nuova riga

un altro metodo invece di fflush (stdin) che invoca un comportamento non definito che puoi scrivere

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

non dimenticare il punto e virgola dopo il ciclo while

Ho riscontrato un problema nel tentativo di implementare la soluzione

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

Inserisco un piccolo aggiustamento "Codice B" per chiunque abbia lo stesso problema.

Il problema era che il programma mi impediva di catturare il carattere "\ n", indipendentemente dal carattere di immissione, ecco il codice che mi ha dato il problema.

Codice A

int y;

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

e l'aggiustamento era quello di 'catturare' il carattere (n-1) appena prima che il condizionale nel ciclo while venisse valutato, ecco il codice:

Codice 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));

La possibile spiegazione è che perché il ciclo while si interrompa, deve assegnare il valore '\ n' alla variabile y, quindi sarà l'ultimo valore assegnato.

Se mi sono perso qualcosa con la spiegazione, il codice A o il codice B per favore dimmelo, sono appena nuovo in c.

spero che aiuti qualcuno

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

-o-

usa forse usa _getch_nolock().. ???

Un'altra soluzione non ancora menzionata è usare: rewind (stdin);

Sono sorpreso che nessuno lo abbia menzionato:

scanf("%*[^\n]");

Breve, portatile e dichiarato in stdio.h

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

Non si blocca in un ciclo infinito quando non c'è nulla su stdin da scaricare come la seguente riga ben nota:

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

Un po 'costoso, quindi non usarlo in un programma che ha bisogno di cancellare ripetutamente il buffer.

Rubato a un collega :)

Prova questo:

stdin->_IO_read_ptr = stdin->_IO_read_end;