esempio di fread dal riferimento C ++

Question

Uso spesso il sito Web www.cplusplus.com come riferimento durante la scrittura del codice C.

Stavo leggendo l'esempio citato nella pagina per fread e aveva una domanda.

Ad esempio, pubblicano:

/* fread example: read a complete file */
#include <stdio.h>
#include <stdlib.h>

int main () {
  FILE * pFile;
  long lSize;
  char * buffer;
  size_t result;

  pFile = fopen ( "myfile.bin" , "rb" );
  if (pFile==NULL) {fputs ("File error",stderr); exit (1);}

  // obtain file size:
  fseek (pFile , 0 , SEEK_END);
  lSize = ftell (pFile);
  rewind (pFile);

  // allocate memory to contain the whole file:
  buffer = (char*) malloc (sizeof(char)*lSize);
  if (buffer == NULL) {fputs ("Memory error",stderr); exit (2);}

  // copy the file into the buffer:
  result = fread (buffer,1,lSize,pFile);
  if (result != lSize) {fputs ("Reading error",stderr); exit (3);}

  /* the whole file is now loaded in the memory buffer. */

  // terminate
  fclose (pFile);
  free (buffer);
  return 0;
}

Mi sembra che se risultato! = lSize, allora free (buffer) non verrà mai chiamato. Questa sarebbe una perdita di memoria in questo esempio?

Ho sempre pensato che gli esempi sul loro sito siano di altissima qualità. Forse non capisco correttamente?

Answer 1

Non sarebbe una perdita di memoria in questo esempio , perché la chiusura del programma (chiamando exit()) libera tutta la memoria ad esso associata.

Tuttavia, sarebbe una perdita di memoria se si usasse questo pezzo di codice come subroutine e si chiamasse qualcosa come return 1; al posto di <=>.

Answer 2

Tecnicamente, sì, è una perdita di memoria. Ma ogni memoria allocata da un processo viene automaticamente liberata quando termina quel processo, quindi in questo esempio le chiamate a free (e fclose) non sono realmente necessarie.

In un programma più complesso, questo sarebbe probabilmente un vero problema. Il libero mancante creerebbe una perdita di memoria e il fclose mancante causerebbe una perdita di risorse.

Answer 3

Il sistema operativo pulisce qualsiasi memoria non ordinata da un processo quando quel processo viene chiuso. Almeno, sistemi operativi moderni .

Answer 4

Se il programma non stava uscendo al punto risultato! = lSize, cioè, ha continuato con qualche altro percorso di esecuzione, quindi sì - è una perdita di memoria garantita.

Answer 5

Esistono due possibili percorsi.

(1) risultato! = lSize - in questo caso viene chiamato exit (0). Questo uccide il processo e il sistema operativo pulirà la memoria.

(2) result == lsize - in questo caso, il buffer viene esplicitamente liberato, ma il ritorno viene chiamato subito dopo, quindi il free è per lo più solo un buon stile perché questo uccide anche il processo e il sistema operativo, ancora, pulirà la memoria.

Quindi, in questo semplice caso, non c'è perdita di memoria. Ma è probabilmente una buona pratica assicurarsi che stai liberando tutta la memoria che hai allocato in qualsiasi applicazione che scrivi. Entrare in questa abitudine eviterà molti mal di testa per te in futuro.

Answer 6

Per quanto riguarda la possibile perdita di memoria, altri hanno già risposto a questa domanda. Qualche tempo fa, ho pubblicato una variante del codice dato che dovrebbe gestire correttamente tutte le possibili condizioni di errore:

• fsize ()
• fget_contents ()