Comment puis-je obtenir la taille d'un fichier en C ?

Question

Comment puis-je connaître la taille d'un fichier que j'ai ouvert avec une application écrite en C ? Je voudrais connaître la taille, car je veux mettre le contenu du fichier chargé dans une chaîne de caractères, que j'alloue à l'aide de malloc() . Il suffit d'écrire malloc(10000*sizeof(char)); est, à mon avis, une mauvaise idée.

Answer 1

Vous devez chercher jusqu'à la fin du dossier et ensuite demander la position :

fseek(fp, 0L, SEEK_END);
sz = ftell(fp);

Vous pouvez alors chercher à nouveau, par exemple :

fseek(fp, 0L, SEEK_SET);

ou (si l'on veut aller au début)

rewind(fp);

Answer 2

Utilisation de la bibliothèque standard :

En supposant que votre implémentation supporte significativement SEEK_END :

fseek(f, 0, SEEK_END); // seek to end of file
size = ftell(f); // get current file pointer
fseek(f, 0, SEEK_SET); // seek back to beginning of file
// proceed with allocating memory and reading the file

Linux/POSIX :

Vous pouvez utiliser stat (si vous connaissez le nom du fichier), ou fstat (si vous avez le descripteur de fichier).

Voici un exemple pour la stat :

#include <sys/stat.h>
struct stat st;
stat(filename, &st);
size = st.st_size;

Win32 :

Vous pouvez utiliser GetFileSize o GetFileSizeEx .

Answer 3

Si vous avez le descripteur de fichier fstat() renvoie une structure stat qui contient la taille du fichier.

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

// fd = fileno(f); //if you have a stream (e.g. from fopen), not a file descriptor.
struct stat buf;
fstat(fd, &buf);
off_t size = buf.st_size;

Answer 4

Avez-vous envisagé de ne pas calculer la taille du fichier et de simplement agrandir le tableau si nécessaire ? Voici un exemple (sans vérification des erreurs) :

#define CHUNK 1024

/* Read the contents of a file into a buffer.  Return the size of the file 
 * and set buf to point to a buffer allocated with malloc that contains  
 * the file contents.
 */
int read_file(FILE *fp, char **buf) 
{
  int n, np;
  char *b, *b2;

  n = CHUNK;
  np = n;
  b = malloc(sizeof(char)*n);
  while ((r = fread(b, sizeof(char), CHUNK, fp)) > 0) {
    n += r;
    if (np - n < CHUNK) { 
      np *= 2;                      // buffer is too small, the next read could overflow!
      b2 = malloc(np*sizeof(char));
      memcpy(b2, b, n * sizeof(char));
      free(b);
      b = b2;
    }
  }
  *buf = b;
  return n;
}

Cela a l'avantage de fonctionner même pour les flux pour lesquels il est impossible d'obtenir la taille du fichier (comme stdin).

Answer 5

Si vous êtes sous Linux, envisagez sérieusement d'utiliser simplement l'option g_file_get_contents de la fonction glib. Elle gère tout le code pour charger un fichier, allouer de la mémoire et gérer les erreurs.