Newsgroup: it.comp.lang.c
Titolo: copia backup di un file

Ciao a tutti,
poiche il progetto su cui sto lavorando talvolta crasha devo far si
che cio non influisca sui successivi utilizzi per fare cio ho la
seguente necessità:
ho un file direction.txt che contiene le info di cui necessito, devo
creare un file direction.txt.temp in cui scrivo le nuove info (di
seguito a quelle già contenute in direction.txt) se tutto va a buon
fine direction.txt.temp deve essere il nuovo direction.txt (in questo
caso basta un rename del file) cosi da avere in quest'ultimo file
sempre dati coerenti.
come posso fare?
Grazie a tutti

ho risolto nel seguente modo a chi puo interessare:
char *buf;
   if ((buf = (char *)malloc((size_t)MAX_PATH)) != NULL)
      dirfile = getcwd(buf, (size_t)MAX_PATH);
    strcat(dirfile, "\\");
    strcat(dirfile, "direction.txt");
    dirfiletemp = (char *) malloc(strlen(dirfile) + 5);
    dirfiletemp[0] = '\0';
    strcpy(dirfiletemp, dirfile);
    strcat(dirfiletemp, ".temp");
    copybefore = (char *)malloc(strlen("ECHO T | COPY ") +
strlen(dirfile) + strlen(dirfiletemp) + 2);
    copybefore[0] = '\0';
    strcat(copybefore, "ECHO T | COPY ");
    strcat(copybefore, dirfile);
    strcat(copybefore, " ");
    strcat(copybefore, dirfiletemp);
    copyafter = (char *)malloc(strlen("ECHO T | COPY ") +
strlen(dirfile) + strlen(dirfiletemp) + 2);
    copyafter[0] = '\0';
    strcat(copyafter, "ECHO T | COPY ");
    strcat(copyafter, dirfiletemp);
    strcat(copyafter, " ");
    strcat(copyafter, dirfile);
    system(copybefore);
   /* elaboro il file*/
    system(copyafter);
Ciaoo

     copybefore = (char *)malloc(strlen("ECHO T | COPY ") +
In che ambiente stai lavorando? A giudicare dall'uso di
ECHO e COPY pare che si tratti di Windows. Se e' cosi' puoi
ricorrere alle API di sistema come CopyFile.
ciao
Giacomo

    copybefore = (char *)malloc(strlen("ECHO T | COPY ") +
<...>
Via i cast.

 Ciaoo
copyafter = malloc (MAX_PATH);
sprintf (copyafter, "ECHO T | COPY %s %s", dirfiletemp, dirfile);
-- 
Abbasso: una delle tre parole (le altre sono viva e morte)
che formano tutto il vocabolario della folla.
                                             - G. Papini -

 la stessa cosa! :)
Mah guarda, io ho riletto il piccolo manualetto che ho di C/C++ e mi
dice di farlo, ma sinceramente se mi devo fidare di quello che dice sto
pezzo di carta mi ci trovo installato windows dopo 4 comandi...
Però è interessante la questione: perché alcuni dicono "si al casting
dopo malloc" e altri "no al casting dopo malloc"?
Ci sono casi dove va usato, e dove non va usato (pena il non
funzionamento del programma)?
Enrico


Beh, io mi riferivo non al cast ma al fatto di allocare un carattere in 
piu' per il '\0' :)
Per il cast, c'e' un thread ("funzione gets") in cui si sta parlando di 
questa cosa, non ne parlerei qui.
ciao
Giacomo

dopo malloc" e altri "no al casting dopo malloc"?
Il casting del valore di ritorno di malloc() ha senso solo in C++ in
cui non c'è conversione implicita da T* a void* e quindi diventa
obbligatorio. In C questa conversione implicita c'è e quindi il cast è
inutile. Non è solo inutile, ma è anche pericoloso, per la presunzione
sul tipo di ritorno di malloc() che il compilatore compie, se non gli
si mostra il prototipo corretto della funzione (i.e. includendo
stdlib.h). In questo caso potrebbero venir fuori fuochi d'artificio.

gabriele wrote:

in stdio.h trovi le funzioni
int remove (const char *filename)
int rename (const char *oldname, const char *newname)
il copy te lo devi implementare, magari così,
ho tolto i controlli su possibili errori per rendere più
chiaro il listato
#include <stdio.h>
#include <stdlib.h>
#define BUFSIZE 128
int main () {
 
  FILE *fpread, *fpwrite;
  char *sorg="pippo.txt", *dest="pluto.txt";
  char *buffer;
  int nbytes, totbytes = 0;
 
  buffer = malloc (BUFSIZE);
  fpread = fopen (sorg,"rb");
  fpwrite = fopen (dest,"wb");
 
  while ( (nbytes=fread(buffer,1,BUFSIZE,fpread)) > 0 ) {
   totbytes += nbytes;
   fwrite (buffer,1,nbytes,fpwrite);
  }
  if ( totbytes )
    printf ("%d bytes copiati\n", totbytes);
 
  fclose (fpread);
  fclose (fpwrite);
  free (buffer);
}
-- 
Gli individui invecchiano ma non il popolo. Esso non invecchia
e non mette senno, rimane sempre infantile.
                                             - J.W. Goethe -