Svuotare il buffer della tastiera...
Gardo
?
Ho un problema con getchar() :-)
--
Grazie e ciao a tutti
(Per favore rispondetemi anche in email)
-----------------------------
mg...@polbox.com
-----------------------------
Enrico Maria Giordano
>
> C'č una funzione di libreria standard per svuotare il buffer della tastiera
> ?
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
ziofester
Io ho sempre usato un trucco:
scanf("%*[^\n]%*c");
Su Linux funziona.
man scanf e ciao.
Gardo wrote:
>
> C'č una funzione di libreria standard per svuotare il buffer della tastiera
> ?
Alessandro Monti
tastiera
> ?
> Ho un problema con getchar() :-)
uso:
while (kbhit())
getchar();
--
Alessandro Monti
Enrico Maria Giordano
>
> scanf("%*[^\n]%*c");
Me lo spiegheresti dettagliatamente? Non ci ho mai capito niente con
questo tipo di cose.
EMG
Bianco
[...]
> Comunque eccoti una funzione che, se pur non portabile, dovrebbe
> funzionare:
>
>#include <stdio.h>
>
>
>void SvuotaInput()
>{
> int c;
>
> do
> {
> c = getchar();
> }
> while ( c != '\n' );
>}
>
Scusa l'ignoranza ma, perche' non e' portabile?
--
Ciao, Luca.
Reply to luca....@tiscalinet.it
UIN : 43385135
ziofester
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.
Stefano Zacchiroli
>
> Enrico Maria Giordano wrote:
> [...]
> > Comunque eccoti una funzione che, se pur non portabile, dovrebbe
> > funzionare:
> >
> >#include <stdio.h>
> >
> >
> >void SvuotaInput()
> >{
> > int c;
> >
> > do
> > {
> > c = getchar();
> > }
> > while ( c != '\n' );
> >}
> >
>
> Scusa l'ignoranza ma, perche' non e' portabile?
>
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"
Enrico Maria Giordano
>
> per scanf la notazione %*d o %*s ... significa [...]
Grazie. Ma tutto ciň č standard o estensione di qualche compilatore?
EMG
Enrico Maria Giordano
>
> 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
ziofester
> Grazie. Ma tutto ciň č standard o estensione di qualche compilatore?
>
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.
Enrico Maria Giordano
>
> Es. \n e' sicuro che in
> ogni implementazione si riferisca alla sequenza usata per endofline
> o si riferisce sempre ad un solo carattere?
Il carattere '\n' è garantito che sia convertito in output in un
new-line adatto al sistema su cui è compilato il programma. Invece in
input non hai nessuna garanzia.
> 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.
In input un new-line può essere gestito in modo portabile solo come
generico white-space.
> 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 */
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
ziofester
> Il carattere '\n' è garantito che sia convertito in output in un
> new-line adatto al sistema su cui è compilato il programma. Invece in
> input non hai nessuna garanzia.
>
Che brutta notizia che mi dai. E mo' che faccio?
> In input un new-line può essere gestito in modo portabile solo come
> generico white-space.
>
Puo' andare bene.
> 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.
>
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.
Andrea Laforgia
#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) *
--------------------------------------------------------
Enrico Maria Giordano
>
> In una sola riga :
>
> while ( getchar() != '\n' ) ;
Giusto! Ottimo!
EMG
Brain
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
Enrico Maria Giordano
>
> > 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?
No. Files aperti con fopen( "nomefile", "w" );.
> 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.
Dio ci salvi dai "professori" di informatica... :-(
EMG
Andrea Laforgia
>Brain wrote:
>>
>> > 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?
>
>No. Files aperti con fopen( "nomefile", "w" );.
...pero' agisce sui buffer, nel senso che li svuota se sono ancora
aperti...
Quindi si può dire che : fflush si applica solo ai buffer dei flussi
aperti in scrittura.
>> 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.
Aspetta, si puo' usare fflush( stdout ) dopo una scanf() ma agisce
comunque sul buffer di scrittura, non di lettura.
Mox
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?
Brain
380c2c39...@diesel.cu.mi.it...
> >No. Files aperti con fopen( "nomefile", "w" );.
>
> ...pero' agisce sui buffer, nel senso che li svuota se sono ancora
> aperti...
>
> Quindi si può dire che : fflush si applica solo ai buffer dei flussi
> aperti in scrittura.
>
> >> 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.
>
> Aspetta, si puo' usare fflush( stdout ) dopo una scanf() ma agisce
> comunque sul buffer di scrittura, non di lettura.
>
Per quanto riguarda sopra ci sono percaso delle differenze tra DOS\Win e
Unix\Linux? Oppure è tutto standard ?
Enrico Maria Giordano
>
> io posso svuotare il buffer della tastiera usando fflush(stdin) giusto?
No.
EMG
Andrea Laforgia
>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?
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.
Mox
>>
>> io posso svuotare il buffer della tastiera usando fflush(stdin) giusto?
>
>
>EMG
No perché è un caso che mi venga accettato dal compilatore?
No perché non segue lo standard?
Enrico Maria Giordano
>
> > > io posso svuotare il buffer della tastiera usando fflush(stdin) giusto?
> >
> > No.
>
> 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
Andrea Laforgia
>Per quanto riguarda sopra ci sono percaso delle differenze tra DOS\Win e
>Unix\Linux? Oppure è tutto standard ?
Tutto standard.