Newsgroup: it.comp.lang.c
Titolo: fscanf su singola riga...

Salve a tutti.
Avrei la necessità di leggere un file fatto in questo modo:
path1 eseguibile1 parametro1
path2 eseguibile2
path3 eseguibile3 parametro3
...
pathn eseguibile parametro
Ho pensato di usare un banale fscanf(file,"%s %s %s",str1,str2,str3),
ma ho questo problema: quando, come nell'esempio, manca la terza stringa,
fscanf va a prendersi la prima stringa della riga successiva,
ovvero in questo caso, mancando "parametro2", lui si prende "path3".
Esiste un modo per far leggere la singola riga in modo che su str3 ci vada
ad esempio NULL?
per il momento ho ovviato al problema mettendo un parametro "dummy",
ed escludendolo con dei controlli ("path2 eseguibile2 dummy").
Vorrei però ottenere un qualcosa di più pulito.
Vi sembra possibile?
Spero di essere stato abbastanza chiaro.
Grazie
    bye ;-)

 Vi sembra possibile?
Beh potresti utilizzare la strtok() vista la formattazione del testo
penso che sia una valida alternativa, però a questo punto devi cambiare
approccio, lasci perdere la fscanf e procedi grossomodo così:
Leggi la riga fino allo \n e poi sulla stringa letta ed acquisita
ci utilizzi sopra la strtok()
Ciao Max
--
 Secondo alcuni autorevoli testi di tecnica Aeronautica,   
 il calabrone non può volare, a causa della forma e del    
 peso del proprio corpo in rapporto alla superficie alare. 
 Ma il calabrone non lo sa e perciò continua a volare.     
                     - Igor Sikorsky -                     

 Ho pensato di usare un banale fscanf(file,"%s %s %s",str1,str2,str3),
Il problema si risolve in maniera banale con strumenti tipo flex, in
maniera un poco piu' complicata leggendosi tutto il file in memoria
e cercando i new line.
Con la scanf() non credo si risolva.
HTH
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 ad esempio NULL?
Si c'e' un metodo facilissimo.
prima di tutto suppongo che tu possa stabilire quanto e'
lunga al massimo la tua riga.
Quindi ti definisci un buffer di dimensione opportuna,
diciamo
char Linea[500];
e supponiamo che il tuo file di ingresso sia filein.
a questo punto in un ciclo:
ripeti
fgets(Linea,500,filein);
che legge una riga dal filein nel buffer Linea.
a questo punto fai cosi'
str1[0]=str2[0]=str3[0]=0;
questa non e' indispensabile, pero' "azzera" le
stringhe nel caso che qualcosa non vada bene nella successiva sscanf.
poi fai
n = sscanf(Linea,"%s %s %s",str1,str2,str3);
dove n e' un int.
Infatti la sscanf e' come la fscanf, solo che legge da una stringa
(il buffer Linea, in questo caso) invece che da un file,
inoltre entrambe le funzioni restituiscono il numero di
variabili lette.
Quindi se la tua linea ha 3 parole avrai n=3
mentre se ne ha due avrai n=2 e inoltre
siccome hai posto str3[0]=0, la stringa str3 sara'
la stringa nulla (correttamente).
considera questo esempio che legge il file
ciccio.txt
ciao,
g.
#include<stdio.h>
#include<stdlib.h>
int main()
{
   FILE *filein;
   char str1[200],str2[200],str3[200],Linea[500];
   int n;
   filein=fopen("ciccio.txt","rb");
   n=1;
   while (n!=0 && n!=EOF)
     {
       fgets(Linea,500,filein);
       str1[0]=str2[0]=str3[0]=0;
       n = sscanf(Linea,"%s %s %s",str1,str2,str3);
       printf("Letti %d : <%s> <%s> <%s>\n",n,str1,str2,str3);
     }
   // si ferma se trova una riga vuota o  EOF
   fclose(filein);
   return 0;
}

 char Linea[500];
Visto che su molti S.O. il path puo' essere 256 caratteri,
questo buffer mi sembra un po' a rischio.
Se proprio non si vuole caricare tutto il file in memoria,
forse sarebbe opportuno prevedere la possibilita' di riallocare
il buffer nel caso fosse insufficiente.
I miei 2 cents... :-)


 il buffer nel caso fosse insufficiente.
Per poter riallocare il buffer bisogna comunque sapere quanto e'
lunga la riga... quindi bisogna leggerla.
Allora 2 soluzioni ragionevoli potrebbero essere
1) Stabilire comunque un limite oltre al quale una linea deve
essere considerata "anomala" e scartata. Per esempio possiamo
andare abbasanza sul sicuro con un buffer di 4001 caratteri.
La fgets non puo' comunque produrre errori di buffer overflow, perche'
conosce la dimensione del buffer. A quel punto, controlliamo
la lunghezza della stringa letta. Se e' di 3999 caratteri
allora abbiamo riempito tutto il buffer e questo e' male, perche'
abbiamo deciso che linee cosi' lunghe sono da scartare.
Per scartarla veramente dobbiamo pero' andare a vedere se l'ultimo
carattere letto nel buffer e' un newline oppure no.
Se lo e' tutto OK, altrimenti vuol dire che la riga era cosi' lunga
che non siamo arrivati al newline, quindi faremo un altra fgets etcetc.
per leggere il residuo etc.etc. (teniamo anche conto del fatto che
il newline potrebbe non esserci se siamo arrivati in fondo al file).
2) Lasciamo perdere la fgets e leggiamo noi, carattere dopo
carattere, il file in un buffer fino a che non troviamo la
fine del file o un ritorno a capo e poi facciamo la sscanf etc.etc.
A seconda dei nostri gusti e di quello che deve fare il programma,
potremo decidere che se la riga che stiamo leggendo dal file
eccede il buffer corrente possiamo scartarla (continuando a leggere
fino a che non troviamo il prossimo finelinea) oppure come diceva 
Angelo, riallocare il buffer e usarne uno piu' grande.
ciao,
g.

 ha scritto nel messaggio
news:c8ut9s$c9c$1...@lacerta.tiscalinet.it...
