[C] Richiesta programma - Gestione File

[c&c]

Ciao a tutti mi servirebbe un programmino in C che apre un file *.txt e quando trova il carattere "\n" lo sostituisce con "" (nulla), in modo che non ci siano gli a capo. piccolo accorgimento se "\n" è preceduto da "-" cancellerà anche "-", il risultato in un nuovo file *.txt.

Ex:
------------ prova.txt -------
Ciao come va? Spero
tutto bene. Ti va di uscire
con me in set-
timana a bere qualcosa
di fres-
co.

----------- ris.txt ---------
Ciao come va? Spero tutto bene. Ti va di uscire con me in settimana a bere qualcosa di fresco.

[TuLKaS85]

carica il file in un array di caratteri a , quindi

i=0;
while (a[i]!='\n'&&a[i]!='-'&&a[i]!=EOF)
{
if(a[i]=='\n'||a[i]=='-')
    a[i]='';
i++;
}

[71104]

Originariamente inviato da c&c

----------- ris.txt ---------
Ciao come va? Spero tutto bene. Ti va di uscire con me in settimana a bere qualcosa di fresco.

veramente in questo esempio non hai rimosso i newlines, li hai sostituiti con uno spazio (tranne ovviamente dove c'era il "-"). ed inoltre dimentichi che solo su Linux i newlines sono semplici "\n": su Mac sono "\r", mentre su Windows sono coppie "\r\n".

[71104]

Originariamente inviato da TuLKaS85

carica il file in un array di caratteri a , quindi

i=0;
while (a[i]!='\n'&&a[i]!='-'&&a[i]!=EOF)
{
if(a[i]=='\n'||a[i]=='-')
    a[i]='';
i++;
}

non funziona correttamente: appena trova un newline o un trattino lo sostituisce (non si sa con cosa visto che '' non è un carattere valido) ed esce senza sostituire tutti i successivi. ed inoltre non è così che c&c intendeva gestire i trattini.

[TuLKaS85]

giustamente
così xò dovrebbe andare

i=0;
while (a[i]!=EOF)
{
if(a[i]=='\n')//mette spazio al posto d'invio probabile ke escono 2 spazi quando c'è l'invio
    a[i]=' ';
if(a[i]=='-')
{
// slitta l'array unendo le parole accapo
  j=i;
 while (a[i]!=EOF)
   {
       a[j]=a[j+1];
       j++;
   }
    
    
}
i++;
}

questo dovrebbe andare se invio viene memorizzato come \n

[71104]

no, non va neanche quello perché EOF non è un char, occupa 2 bytes; ed inoltre la fread non te lo mette nell'array, devi mettercelo manualmente.

EDIT: anche se EOF fosse un byte singolo non andrebbe lo stesso perché l'algoritmo per slittare l'array è bacato (off-by-one, non slitta l'EOF), ed inoltre non elimini il newline dopo il trattino.

[TuLKaS85]

Originariamente inviato da 71104

no, non va neanche quello perché EOF non è un char, occupa 2 bytes; ed inoltre la fread non te lo mette nell'array, devi mettercelo manualmente.

EDIT: anche se EOF fosse un byte singolo non andrebbe lo stesso perché l'algoritmo per slittare l'array è bacato (off-by-one, non slitta l'EOF), ed inoltre non elimini il newline dopo il trattino.

beh il newline lo elimina mettendoci spazio al prossimo ciclo, quando fa il primo if, per quanto riguarda l'eof mi ricordo che lo usavo anche con le strighe poi non saperei.... cmq è facile modificare l'idea....

i=0;
while (a[i]!=EOF)
{
if(a[i]=='\n')//mette spazio al posto d'invio probabile ke escono 2 spazi quando c'è l'invio
    a[i]=' ';
if(a[i]=='-')
{
// slitta l'array unendo le parole accapo
  j=i;
 while (a[j]!=EOF)
   {
       a[j]=a[j+1];
       j++;
   }
a[j-1]=a[j];  //copia l'eof
    
    
}
i++;
}

vediamo un pò

[trallallero]

@c&c: certo che du' righe potevi almeno provare a tirarle giú

#include <stdio.h>

int main(void)
{
   FILE *pIn  = fopen( "input.txt" , "r" ),
        *pOut = fopen( "output.txt", "w" );

   if (!pIn)
      puts("errore apertura file di input"), exit(1);

   if (!pOut)
      puts("errore apertura file di output"), exit(1);

   while (1) // SE FAI while(!feof(pIn)) DEVI RICONTROLLARE DOPO LA LETTURA
   {
      int c = fgetc(pIn); // LEGGO

      if ( feof(pIn) )
         break;

      if (c == '\n' || c == '\r' || c == '-' ) // SALTO IL CARATTERE
         continue;

      fputc( c, pOut ); // SCRIVO
   }
   fputc( '\n', pOut );
   
   fclose(pIn);
   fclose(pOut);
   
   return 0;
}

[Ziosilvio]

Originariamente inviato da c&c

Ciao a tutti mi servirebbe un programmino in C che apre un file *.txt e quando trova il carattere "\n" lo sostituisce con "" (nulla), in modo che non ci siano gli a capo. piccolo accorgimento se "\n" è preceduto da "-" cancellerà anche "-", il risultato in un nuovo file *.txt.

Fare tu i tuoi compiti proprio no, eh?

[-fidel-]

Non mi sembra didattico postare subito il codice giusto, forse è meglio che lo fate prima ragionare (è evidentemente un esercizio di programmazione che deve fare come compito...)

[71104]

Originariamente inviato da TuLKaS85

beh il newline lo elimina mettendoci spazio al prossimo ciclo,

no: al prossimo ciclo lo sostituisci con uno spazio, mentre in quel caso lo devi proprio eliminare.

per quanto riguarda l'eof mi ricordo che lo usavo anche con le strighe poi non saperei....

chiunque te lo può confermare

cmq è facile modificare l'idea....

[cut]

vediamo un pò

rimane il fatto che EOF occupa 2 bytes, non 1. ed inoltre non elimini il newline dopo il trattino.

[71104]

@trallallero: il tuo codice ha un paio di problemi:
1) non scrive lo spazio se incontra un newline non preceduto dal trattino
2) mettere fgetc prima di feof secondo me è sbagliato perché se siamo in condizione di EOF fgetc stessa ritorna EOF; ovvero, se feof ti ritorna non-zero vuol dire che sicuramente fgetc ritornerà EOF (almeno così ho capito da www.linuxmanpages.com)

ed infine questa parte di codice:

FILE *pIn  = fopen( "input.txt" , "r" ),
        *pOut = fopen( "output.txt", "w" );

   if (!pIn)
      puts("errore apertura file di input"), exit(1);

   if (!pOut)
      puts("errore apertura file di output"), exit(1);

nel caso specifico non da' problemi, ma in generale può causare leak. il discorso che in questo caso non badi ai leak perché tanto il programma termina subito non vale, perché in tal caso il codice manca di metodologia coerente (perché alla fine fai fclose...?)

[trallallero]

Originariamente inviato da -fidel-

Non mi sembra didattico postare subito il codice giusto, forse è meglio che lo fate prima ragionare (è evidentemente un esercizio di programmazione che deve fare come compito...)

me culpa
che poi sono il primo a criticare chi chiede tutto e subito.
Ma stamattina non avevo 'na ceppa da fare e tra il parlar male di Prodi in politica e fare un mini C ho optato per la seconda

[-fidel-]

Originariamente inviato da 71104

nel caso specifico non da' problemi, ma in generale può causare leak. il discorso che in questo caso non badi ai leak perché tanto il programma termina subito non vale, perché in tal caso il codice manca di metodologia coerente (perché alla fine fai fclose...?)

Normalmente, se non per abitudine nello scrivere buon codice, è inutile chiudere i vari riferimenti, handle, file descriptors ecc. prima di terminare (anche se, effettivamente, nel codice che hai quitato lo si fa a metà: o tutto o niente, condivido ). Certo, è buona norma ricordarsene perché poi c'é il rischio di non chiuderli mai (anche quando il programma non deve terminare) andando incontro facilmente a memory leaks (e situazioni simili, come dangling pointers).
Sono in cerca di situazioni che causano memory leaks anche dopo la terminazione di un programma (insomma, funzioni che si riservano memoria nel loro spazio dei processi (ma non solo), e che non viene liberata (se non esplicitamente) anche dopo aver terminato.
Forse la shared memory?

[trallallero]

Originariamente inviato da 71104

@trallallero: il tuo codice ha un paio di problemi:
1) non scrive lo spazio se incontra un newline non preceduto dal trattino

vero. L'ho anche testato ma non mi sono accorto

Originariamente inviato da 71104

2) mettere fgetc prima di feof secondo me è sbagliato perché se siamo in condizione di EOF fgetc stessa ritorna EOF; ovvero, se feof ti ritorna non-zero vuol dire che sicuramente fgetc ritornerà EOF (almeno così ho capito da www.linuxmanpages.com)

dici ? quindi forse é meglio:

      int c = fgetc(pIn); 

      if ( c == EOF || feof(pIn) )
         break;

Originariamente inviato da 71104

ed infine questa parte di codice:

FILE *pIn  = fopen( "input.txt" , "r" ),
        *pOut = fopen( "output.txt", "w" );

   if (!pIn)
      puts("errore apertura file di input"), exit(1);

   if (!pOut)
      puts("errore apertura file di output"), exit(1);

nel caso specifico non da' problemi, ma in generale può causare leak. il discorso che in questo caso non badi ai leak perché tanto il programma termina subito non vale, perché in tal caso il codice manca di metodologia coerente

eh la madonna su un programma che aggiusta 3 righe di testo mi vieni a parlare di metodologia coerente ?
Cosa intendi per leak ? il fatto che non chiudo il primo file se fallisce il secondo ? si é una svista

Originariamente inviato da 71104

(perché alla fine fai fclose...?)

sono abituato a chiudere la porta quando esco

[71104]

Originariamente inviato da trallallero

dici ? quindi forse é meglio:

      int c = fgetc(pIn); 

      if ( c == EOF || feof(pIn) )
         break;

no, io dicevo proprio di mettere feof come condizione nel while...

perché non ce l'hai messa? che male ti faceva?

[...] si é una svista

sono abituato a chiudere la porta quando esco

e se hai due porte ne chiudi solo una?

[trallallero]

Originariamente inviato da 71104

no, io dicevo proprio di mettere feof come condizione nel while...
perché non ce l'hai messa? che male ti faceva?

perché se lo metti nella condizione poi lo devi ricontrollare quando leggi.
L'ho messo nel commento

Originariamente inviato da 71104

e se hai due porte ne chiudi solo una?

guarda oggi sto vicino ad una crisi di nervi ( voglio il divorzio )
giá tanto che sia riuscito ad aprire e leggere un file

[71104]

Originariamente inviato da -fidel-

Sono in cerca di situazioni che causano memory leaks anche dopo la terminazione di un programma (insomma, funzioni che si riservano memoria nel loro spazio dei processi (ma non solo), e che non viene liberata (se non esplicitamente) anche dopo aver terminato.
Forse la shared memory?

hmm, no... secondo me in Win32 di simile trovi sostanzialmente solo gli handle User e GDI (finestre e oggetti grafici).

[71104]

Originariamente inviato da trallallero

perché se lo metti nella condizione poi lo devi ricontrollare quando leggi.
L'ho messo nel commento

ma perché...? scusa eh...
- se non siamo a EOF, prima feof restituisce 0 e poi fgetc resituisce un carattere
- se siamo a EOF, feof restituisce non-zero facendoti uscire dal ciclo perché se entrassi fgetc restituirebbe EOF

perché mai devi ricontrollare dopo la fgetc...?

guarda oggi sto vicino ad una crisi di nervi ( voglio il divorzio )

ok, allora consiglio da amico: sbattitene ampiamente del C (che non può che peggiorare la tua situazione nervosa) e rappacificati con la muliere

dai su, che quando avete fatto pace vi amate ancora più di prima ("l'amore non è bello se non è litigarello", ti giuro che è vero )

[Qu@ker]

<e a questo punto il Docente, bonariamente, giocherella con il libretto e chiede>
Quando è, secondo Lei, che viene settato l'indicatore di eof, in C (e non, poniamo, in Pascal)?