Newsgroup: it.comp.lang.c
Titolo: Dimensione di un file dati

Salve a tutti,
non riesco a trovare il modo di determinare la lunghezza di un file 
di dati.
Il file e' fatto da una colonna di mumeri e vorrei avere una funzione 
che prende il puntatore al file e restituisce la lunghezza della 
colonna.
Grazie a chiunque mi possa rispondere.
Ciaoooooooooo
Inviato da 
www.mynewsgate.net

 colonna.
bhe.. in questo caso non vuoi sapere qual'è la dimensione del file ma quante
righe ha....
è sbagliato immaginare un file a righe...
cioè.. il tuo file in realtà è salvato così: (+o-)
44\n45\n66\n1\n77\n99\n...
per trovare la lunghezza puoi farti una funzioncina!
int lung (FILE *fr)
{
char stringa[101];
int i=0;
   while (!feof(fr))
  {
    fgets(stringa,100,fr);
    i++;
   }
return i;
}
non son sicuro che ti ritorni il numero esatto.. il numero +1... o qualcosa
del genere...
cyao
Fra

 colonna.
Cioe` vuoi sapere il numero di righe? Potresti contare il numero di
newline presenti nel file.
Kronos
-- 
Home: 
http://kronoz.cjb.net
Il piu` bel momento dell'amore e` quando ci si illude che duri per 
sempre; il piu` brutto, quando ci si accorge che dura da troppo.

 }
Questa funzione ha diversi problemi:
1) int potrebbe essere di 16 bit, ed essendo con segno se il file e`
    piu` lungo di 32000 e qualcosa righe ci sara` overflow, con
    risultati inaspettati (probabilmente conteggio errato). Proporrei
    unsigned long per una maggiore sicurezza. (Questo vale nel caso di un
    programma d'uso generico, se poi si tratta di un semplice esercizio
    possiamo anche soprassedere).
2) fgets() legge n - 1 caratteri, quindi se il buffer e` di 101 il
    secondo parametro puo` essere tranquillamente 101 (a meno di voler
    sprecare apposta un char).
3) Se una riga e` piu` lunga di 100 caratteri sara` conteggiata due
    volte. Questo si puo` ignorare se e` garatito che nel file una
    riga non superi i 100 caratteri (newline compreso).
4) La condizione del while e` sbagliata (infatti come tu stasso dici
    conta una riga in piu`). Questo perche` feof() sara` vera solo
    *dopo* che fgets() ha tentato di leggere ed e` fallita, quindi il
    ciclo sara` eseguito una volta in piu` del dovuto. Una condizione
    migliore e`:
        while (fgets(stringa, 101, fr) != NULL)
Visti i numerosi problemi, probabilmente e` piu` semplice leggere un 
carattere alla volta e contare gli '\n'.
-- 
Enrico 'Trippo' Porreca

 Grazie a chiunque mi possa rispondere.
Per contare le linee fai in questo modo:
int main(void)
{
  int num_lines = 0;
  int c;
  while((c = getchar()) != EOF)
  {
    if(c == "\n")
      num_lines++;
  }
  printf("num_lines: %d\n", num_lines);
}
-- 
Lawrence "Rhymes" Oluyede
http://loluyede.blogspot.com
rhy...@NOSPAMmyself.com

 }
scusami ma in questo modo mica viene controllato i caratteri presenti all'
interno del file???

 interno del file???
Spero di aver capito la domanda... Questo programma conta il numero di 
newline, quindi il numero di righe (in un file di testo tutte le righe 
sono terminate da newline).
-- 
Enrico 'Trippo' Porreca

 interno del file???
Mmm faccio fatica a capire a causa del "bad italian" :P
Comunque quel programma non fa altro che contare le linee
nel file, se proprio vuoi contare anche i caratteri e` una stupidata
aggiungere la cosa



scusatemi ora mi esprimo meglio.....
io so che con getchar è possibile memorizzare caratteri presi dallo
stdin.... quindi
c = getchar()  chiede all' utente di inserire un carattere... questo
carattere verrà poi memorizzato in c.
Viene poi controllato se la variabile 'c'   è un newline, in questo caso
viene incrementato num_lines.
Tutto questo fin quando non vi è la fine del file...
ma la fine di quale file???
----------------------------------------------------------------------------
------------------------
io faccio in questo modo:
.......
FILE *fp;
char c;
float dim, num_lines=0;
fp = fopen("prova.txt", "r");
fseek(fp,0,SEEK_END); //dimensione
dim=ftell(fp);                    //del file
rewind(fp);
while(fp < dim)
{
fscanf(fp, "%c", &c);
fseek(fp,1,SEEK_CUR);
if(c == '\n')
num_lines++;
}
mi sono complicato la vita????
aspetto vostre risposte..... ciao

 ma la fine di quale file???
Legge dallo stdin, che non e` necessariamente la tastiera.
Hint: proggy < file.txt
Kronos
-- 
Home: 
http://kronoz.cjb.net
"In linea di principio sarei indifferente al natale, se solo il natale
 ricambiasse la cortesia e mi lasciasse in pace." -- Marco d'Itri

 mi sono complicato la vita????
Direi di si`. Molto piu` semplice:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
     int c;
     unsigned long n_lines = 0;
     FILE *file = fopen(FILE_NAME, "r");
     if (file == NULL) {
         return EXIT_FAILURE;
     }
     while ((c = getc(file)) != EOF) {
         if (c == '\n') {
             n_lines++;
         }
     }
     printf("%lu\n", n_lines);
     return 0;
}
-- 
Enrico 'Trippo' Porreca

 }
ok ora mi trovo, perchè in questo modo noi leggiamo un carattere dal file
aperto e non dallo stdin.
Però mi sono sorte altre due domande al proposito :-D
1) se noi non facciamo fseek(file, 1, SEEK_CUR) lo stream come fa a puntare
al prossimo carattere???
2) se io faccio
scanf("%d", &a);
scnaf("%d", &b);
rewind(stdin);
fseek(stdin,sizeof(int),SEEK_CUR);
stdin punta al valore immesso nella variabile b??
ciao....

 stdin punta al valore immesso nella variabile b??
Questa domanda mi ha colto completamente alla sprovvista. Personalmente 
non avevo mai pensato di usare rewind() oppure fseek() sullo stdin.
Immediatamente ho pensato: certamente non e` lecito farlo. Ovviamente mi 
sono messo a cercare nello standard, pero` questo non dice nulla. Da 
cio` deriva che, essendo stdin uno stream come gli altri, e` lecito farlo.
Una ricerca negli archivi di comp.lang.c mi ha illuminato: in effetti, 
sia rewind() che fseek() hanno il diritto di fallire (rewind() pero` non 
puo` segnalarlo con il suo valore di ritorno, dato che non ne ha). 
Quindi: si puo` fare, ma non si sa cosa si otterra`.
Ad esempio, sul mio sistema fseek() sullo stdin fallisce. Ecco il codice 
che ho usato per il test:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main(void)
{
     if (fseek(stdin, 0, SEEK_CUR) != 0) {
         fprintf(stderr, "fseek() error: %s\n", strerror(errno));
         return EXIT_FAILURE;
     }
     puts("fseek() success");
     return 0;
}
L'output e`:
fseek() error: Bad file descriptor
Conclusione: non si puo` prevedere cosa succedera`. La risposta alla tua 
domanda e` quindi: in generale, non puoi farlo.
PS: Grazie per lo spunto :-)
-- 
Enrico 'Trippo' Porreca

 domanda e` quindi: in generale, non puoi farlo.
Si puo` aggiungere anche che, nel caso lo stdin venga rediretto su un 
file `normale' per cosi` dire, la fseek() dovrebbe funzionare 
correttamente. Basta comunque verificare il valore che restuisce.
-- 
Enrico 'Trippo' Porreca

cio` deriva che, essendo stdin uno stream come gli altri, e` lecito farlo.
E` lecito farlo, ma credo che il comportamento sia "undefined".
Ad esempio, con tutte le versioni di Microsoft C (compreso il Visual
C++), un rewind() su stdin č sempre servito a svuotare il buffer della
tastiera.  Per altri sistemi, perň, potrebbe non essere cosě.

 mi sono complicato la vita????
Si


 writes:
Rieccomi ;-)
allora:
 while((c = getchar()) != EOF)
  {
    if(c == "\n")
      num_lines++;
  }
  printf("num_lines: %d\n", num_lines);
}
 La domanda che mi sorge č: il getchar legge dallo stdin o dal file aperto??
L' obiettivo era quello di leggere le righe presenti all' interno di un
file(di testo, credo). Ma con getchar noi leggiamo dallo stdin e non dal
file.... quindi non mi spiego come mai il programma dovrebbe leggere le
linee presenti all' interno del file(di testo, credo :-))
inoltre lo stdin punta ad un device..... la Tastiera, ma non riesco ad
immaginarmi come funziona lo stream standard dell' input.
-------------------------------------------------------
nell' stdio tradotto in linguaggio C dovrebbe esserci un cosa del genere,
credo:
FILE *stdin;
if(!(stdin = ????))
fprintf(stderr, "input error");
exit(1);
Al posto dei punti interrogativi cosa c' č?? L' interrupt alla tastiera???
non credo.
grazie di tutto.....
ciao

  La domanda che mi sorge č: il getchar legge dallo stdin o dal file aperto??
Legge dallo stdin e se gli passi il file nello stdin in questo modo:
$ programma < file.txt
sei apposto. altrimenti se non ti aggrada guarda il resto del thread
in cui ti hanno fornito soluzini valide


 carattere alla volta e contare gli '\n'.
gia'!

 tastiera.  Per altri sistemi, però, potrebbe non essere così.
E` quello che risulta anche a me dopo la mia ricerca.
-- 
Enrico 'Trippo' Porreca