Newsgroup: it.comp.lang.c
Titolo: Problemino...

Ecco l'arcano : vorrei usare la combinazione printf("%d",i) e
printf("\b") per visualizzare un contatore ma il risultato e' che non
viene stampato nulla! Ecco il testo della prova:
#include <unistd.h>
#include <stdio.h>
int main(void) {
  int i;
  for (i=0; i<10; i++) {
    printf("%d",i);  /* numero 0-9 */
    sleep(1);	     /* pausa di un secondo */
    printf("\b");    /* backspace */
  }
  return 0;
}
Questo dovrebbe stampare 0, 1, 2 ... 9 ad intervalli di 1 secondo, ma il
risultato e' "un bel nulla!": si limita a terminare dopo 10 secondi.
L'ho compilato con gcc -Wall -pedantic -ansi -O3 (ho provato anche senza
l'ottimizzazione), ed eseguito sotto linux.
Ho provato con le stesse opzioni con djgpp sotto win95 e il risultato e'
lo stesso.
Un grazie a chi legge e due a chi risponde ;-)
-- 
 Ciao, Luca.
 Reply to 
luca....@tiscalinet.it
 UIN : 43385135

Sei sicuro che sleep voglia i secondi e non i millisecondi?
-- 
Togliere ICEMAN dall'indirizzo per l'e-mail
Bye
   Nameci


SLEEP(3)            Linux Programmer's Manual            SLEEP(3)
NAME
       sleep - Sleep for the specified number of seconds
-- 
Zack
Stefano Zacchiroli
zacc...@cs.unibo.it
za...@comune.budrio.bo.it
ICQ# 33538863
"Never understimate the dark side"

prova a fare un fflush di stdout...
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

 wrote:
[ snip ]
B>  for (i=0; i<10; i++) {
B>    printf("%d",i);  /* numero 0-9 */
Aggiungi qui
      fflush(stdout);
Ciao ciao,
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

lo stesso.
Ho compilato il codice con DJGPP sotto Win95 e funziona perfettamente.
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)

       fflush(stdout);
Ok, grazie, adesso funziona.


 
Sei sicuro? A me funziona come deve solo se inserisco la modifica
consigliata da Maurizio e Andrea, ossia fflush(stdio); mah, chissa' per
quale motivo...


quale motivo...
Ripeto : il codice funziona perfettamente, compaiono dei numeri in
sequenza nella stessa posizione del video per 10 volte scanditi con un
tempo di 1 secondo l'uno dall'altro.
Io ho semplicemente tagliato e incollato il codice in RHIDE, compilato
ed eseguito.
Risultato : funziona.
La modifica in questione dovrebbe essere necessaria solo nel caso in
cui l'output è bufferizzato ( fflush( stdout ) ).
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)

 viene stampato nulla!
A me funziona come dovrebbe: stampa i numeri da 0 a 9 ad intervalli di un
secondo.
Ciao, Giuseppe
---------------------------------------------------------------------------
_Guybrush su IRCNet canale #programmazione
ICQ: 42227764
---------------------------------------------------------------------------

Andrea Laforgia wrote:

A me risulta che l'output che si ottiene con
la printf sia bufferizzato
(anche se, al solito, non mi ricordo dove l'ho letto).
Senza la fflush puo`  accadere (ad esempio, ma non
necessariamente) che:
viene eseguita la prima printf, ma questa stampa
in un buffer che non viene riversato su stdout.
Alla esecuzione della seconda printf il buffer
puo` anche essere riversato su stdout, ma poiche` contiene
una cifra e un successivo backspace il risultato
e` che non si vede niente e cosi via ogni secondo
(credo che nessuno garartisca che il buffer venga
svuotato solo quando e` pieno. Il sistema dovrebbe
essere libero di gestire come vuole
il flushing del buffer, a meno che non lo si forzi.
Comunque anche nel caso in cui il buffer
fosse pieno e venisse svuotato tutto in una volta
potrebbe non vedersi niente, o comunque
solo una specie di flash, data la presenza di coppie
cifra-backspace).
Se il buffer non viene mai svuotato fino
a quando e` pieno chiaramente nel caso del codice
suddetto non si vedrebbe niente ( 20 caratteri non
riempiono il buffer, probabilmente) .
Comunque, poiche` il flushing del buffer se lo gestisce
il sistema (se non si mette fflush) nulla vieta che il codice
su alcune installazioni funzioni, su altre no
(in genere nei sistemi Unix-like non funziona mai
o quasi mai, se non si inserisce una fflush, o uno \n
nella stringa da stampare).
Anzi, addirittura capita talvolta che una printf p1 che
e` stata eseguita sicuramente
dopo di un'altra printf p2
da` un output (di p1) che viene visualizzato prima
di quello di p2 (il che puo` accadere se due processi
diversi, anche se sincronizzati bene per il resto ma senza
"flushare" il buffer, usano due buffer diversi. A me questa
cosa e` capitata la prima volta che ho provato a scrivere un
programma multiprocesso. Il S.O. era IBM Aix).
Marco Guidi.

la printf sia bufferizzato
Anche a me risulta così, in quanto non è una questione dipendente
dalla funzione, quanto dal modo di gestire l'output da parte del
compilatore.
Però nel caso del djgpp c'è differenza, ad esempio, tra il
comportamento di putchar() e quello di printf().
Supponendo di avere un programma del genere :
#include <stdio.h>
main()
{
    int i, c ;
    putchar( 'a' ) ;
    c = getchar() ;
}
L'output di putchar() compare al momento della chiamata a getchar()
(come ci si aspetterebbe, trattandosi di output bufferizzato).
Nel caso invece di 
#include <stdio.h>
main()
{
    int i, c ;
    printf( "prova" ) ;
    c = getchar() ;
}
L'output di printf() compare al momento stesso della chiamata (prima
di getchar()) e questo è il motivo per cui un fflush() risulta inutile
ed il programma gira correttamente.
Il caso, poi, della visualizzazione dei caratteri è trattato
diversamente dalla printf() che accompagna il djgpp.
I caratteri, infatti, non vengono cancellati con la sequenza di escape
\b ma si sposta soltanto il cursore di una posizione indietro.
Questo è il motivo per cui l'output è ben visibile.
Entrambe le questioni quindi sono "implementation-dependent".
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)