Newsgroup: it.comp.lang.c
Titolo: Svuotare il buffer della tastiera...

C'è una funzione di libreria standard per svuotare il buffer della tastiera
?
Ho un problema con getchar() :-)
--
Grazie e ciao a tutti
(Per favore rispondetemi anche in email)
-----------------------------
mg...@polbox.com
-----------------------------

 ?
No. Comunque eccoti una funzione che, se pur non portabile, dovrebbe
funzionare:
#include <stdio.h>
void SvuotaInput()
{
    int c;
    do
    {
        c = getchar();
    }
    while ( c != '\n' );
}
int main()
{
    int c;
    do
    {
        printf( "Inserisci un carattere (0 per finire): " );
        c = getchar();
        printf( "Hai premuto %c\n", c );
        SvuotaInput();
    }
    while ( c != '0' );
    return 0;
}
EMG

 ?


 Ho un problema con getchar() :-)
Standard non ne conosco, per dos c'è la kbhit()
uso:
while (kbhit())
    getchar();
--
Alessandro Monti

 scanf("%*[^\n]%*c");
Me lo spiegheresti dettagliatamente? Non ci ho mai capito niente con
questo tipo di cose.
EMG


Scusa l'ignoranza ma, perche' non e' portabile?
-- 
 Ciao, Luca.
 Reply to 
luca....@tiscalinet.it
 UIN : 43385135

per scanf la notazione %*d o %*s ... significa di leggere i campi
corrispondenti con i formati specificati SENZA assegnare i valori
ad ad alcun puntatore che infatti manca alla lista parametri.
la notazione %[qwerty] significa di LEGGERE COME STRINGA fin quando
non si incontra un carattere diverso da quelli contenuti nella lista.
Tutti i caratteri della stringa letta vengono memorizzati in un char *
se ma se %*[qwerty] non vengono mem da nessuna parte. l' unico carattere
diverso, che ha causato la terminazione, rimane pronto per il prossimo
input.
la notazione %[^qwerty] al contrario, legge tutti i caratteri fino a che
non si incontra uno di quelli contenuti nella lista, che rimane
disponib.
per altra lettura. Il carattere ^ usato per primo ha senso come
negazione.
Cosi' si possono leggere stringhe contenenti spazi, tab e newline es:
scanf("%[^#]",stringa); /* legge tutto fino a # */
                         /* la prossima getchar() ritornera' '#' */
                         /* che non e' stato letto */
quindi io ho usato scanf per leggere tutto, scartando, fino a newline
(\n)
e poi ho letto anche quello e scartato.
ciao.


 
Perche' non e' detto che quando si preme invio sulla tastiera,
venga memorizzato un '\n' !
-- 
Zack
Stefano Zacchiroli
zacc...@cs.unibo.it
za...@comune.budrio.bo.it
ICQ# 33538863
"Never understimate the dark side"

 per scanf la notazione %*d o %*s ... significa [...]
Grazie. Ma tutto ciň č standard o estensione di qualche compilatore?
EMG

 Scusa l'ignoranza ma, perche' non e' portabile?
Non so esattamente. Leggi questo dalle FAQ:
12.26:  How can I flush pending input so that a user's typeahead isn't
        read at the next prompt?  Will fflush(stdin) work?
A:      fflush() is defined only for output streams.  Since its
        definition of "flush" is to complete the writing of buffered
        characters (not to discard them), discarding unread input would
        not be an analogous meaning for fflush on input streams.
        There is no standard way to discard unread characters from a
        stdio input stream, nor would such a way necessarily be
        sufficient, since unread characters can also accumulate in
        other, OS-level input buffers.  You may be able to read and
        discard characters until \n, or use the curses flushinp()
        function, or use some system-specific technique.  See also
        questions 19.1 and 19.2.
        References: ISO Sec. 7.9.5.2; H&S Sec. 15.2.
EMG

 
Si, e' standard. Ma parlando di printf e scanf a volte i produttori
di compilatori interpretano come vogliono. Es. \n e' sicuro che in
ogni implementazione si riferisca alla sequenza usata per endofline
o si riferisce sempre ad un solo carattere?
In DOS funziona lo stesso perche' \r\n ha come secondo carattere \n,
se se fosse stato \n\r avrebbe funzionato? Io direi che DEVE funzionare
sempre se per quella piattaforma e' stata definita una certa sequenza di
file linea. Se printf("\n"); produce non un singolo carattere, ma una
sequenza DEVO avere uno strumento svincolato dalla piattaforma OS per
rigestirma in input. Se pero' il compilatore che hai ha precedentemente
opianto a questo, alla fine, o cambi compilatore o gli dai ragione.
Una volta credevo di aver fatto una cosa astuta per allinearmi al
prossimo
campo di input eliminando spazi, tab e newlines cosi':
scanf("%*0s"); /* leggi una stringa lunga 0 char e buttala via */
Lo standard dice che un input di stringa inizia dal primo char non di
spaziatura (credo per char per cui isprint() e vera) e termina con
il primo char di spaziatura o newline (escluso).
Su Borland Ł.0 su DOS funzionava e l' ho largamente usata, ma con gcc
e libc si mangiava comunque il primo char della stringa. Potrei
insinuare
un bug delle libc di allora (oggi non ho verificato perche' ho
rinunciato
al metodo.)
Scusa se sono andato lungo.
Ciao.

 scanf("%*0s"); /* leggi una stringa lunga 0 char e buttala via */
Ma è necessaria questa cosa? Il prossimo campo di input è
automaticamente allineato dato che gli white-spaces vengono saltati
dalla scanf(). Quindi secondo me è giusto che si mangi il primo
carattere del prossimo campo.
EMG

 
Quella volta dovevo leggere da un tabulato ASCII output di un programma
DB4 che dopo un campo stringa di lunghezza variabile valeva, Y o N.
A cha ha fatto lo script in DB4 ho commissionato di terminare i campi
di lunghezza variabile con #, poi, per non avere troppa roba in testa
e risolvere al piu' presto il problema di statistiche sui record, ho
risolto
con una unica stringa di formato di scanf(), leggendo fino a # e poi
saltando
gli spazi fino al prossimo char non di spaziatura. Con Borland 3.0 OK,
ma se
avessi avuto AWK allora ....
ciao.

you wrote :
#C'č una funzione di libreria standard per svuotare il buffer della tastiera
#?
#Ho un problema con getchar() :-)
In una sola riga :
while ( getchar() != '\n' ) ;
--------------------------------------------------------
* Andrea Laforgia        (
andrea_...@bigfoot.com
) *
--------------------------------------------------------

 while ( getchar() != '\n' ) ;
Giusto! Ottimo!
EMG

> Non ne conosco. fflush si applica solo ai flussi aperti in scrittura.
Susate l'ignoranza.
Per "flussi aperti in scrittura" intendete i/il buffer di scrittura e simili?
Il mio prof. di info2 diceva che fflush si poteva usare anche in lettura........
per esempio quando la scanf(...) non sposta il puntatore del buffer.
--
___________________________________________________
Togliete NOSPAM dall'indirizzo se volete rispondermi...
bye Brain

 per esempio quando la scanf(...) non sposta il puntatore del buffer.
Dio ci salvi dai "professori" di informatica... :-(
EMG

> per esempio quando la scanf(...) non sposta il puntatore del buffer.
Aspetta, si puo' usare fflush( stdout ) dopo una scanf() ma agisce
comunque sul buffer di scrittura, non di lettura.


Scusate il post, ma mi sono perso alcuni messaggi precedenti e
gradirei avere un chiarimento: io posso svuotare il buffer della
tastiera usando fflush(stdin) giusto? O almeno io la utilizzavo sotto
Unix e sotto DOS e mi ha sempre funzionato.
Il metodo che ho utilizzato č standard? Se non č standard come mai
funziona sotto vari compilatori e sistemi operativi senza problemi?


Per quanto riguarda sopra ci sono percaso delle differenze tra DOS\Win e
Unix\Linux? Oppure è tutto standard ?


 io posso svuotare il buffer della tastiera usando fflush(stdin) giusto?
No.
EMG

funziona sotto vari compilatori e sistemi operativi senza problemi?
Non e' standard, nel senso che non ha un comportamento definito.
Il comportamento di fflush( stdin ) e' definito in modo standard solo
per gli stream di output.
Il termine "undefined" per lo standard ha un significato ben preciso e
lascia libertà agli implementatori del linguaggio di offrire un
comportamento valido da parte di questa funzione, nel caso si ponga
come argomento il flusso standard di input.
Questo significa che alcune implementazioni possono assolvere al
compito che ci si prefigge ed altre no.


EMG
No perché è un caso che mi venga accettato dal compilatore?
No perché non segue lo standard?

 No perché non segue lo standard?
Scusa della stringatezza della risposta. Non puoi utilizzare
fflush(stdin) in quanto non è previsto dallo standard. Usa invece
while ( getchar() != '\n' );
EMG

Unix\Linux? Oppure è tutto standard ?
Tutto standard.
