Comment déterminer la taille d'un fichier en C ?

Question

Comment puis-je connaître la taille d'un fichier, en octets ?

#include <stdio.h>

unsigned int fsize(char* file){
  //what goes here?
}

Answer 1

Sur les systèmes de type Unix, vous pouvez utiliser les appels système POSIX : stat sur un chemin ou fstat sur un descripteur de fichier déjà ouvert (POSIX page de manuel Linux page de manuel ).
(Obtenir un descripteur de fichier à partir de open(2) ou fileno(FILE*) sur un flux stdio).

Basé sur le code de NilObject :

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

off_t fsize(const char *filename) {
    struct stat st; 

    if (stat(filename, &st) == 0)
        return st.st_size;

    return -1; 
}

Changements :

• Faire de l'argument du nom de fichier un const char .
• Corrigé le struct stat qui n'avait pas le nom de la variable.
• Renvoie à -1 en cas d'erreur, au lieu de 0 ce qui serait ambigu pour un fichier vide. off_t est un type signé, ce qui est donc possible.

Si vous voulez fsize() pour imprimer un message en cas d'erreur, vous pouvez utiliser ceci :

#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

off_t fsize(const char *filename) {
    struct stat st;

    if (stat(filename, &st) == 0)
        return st.st_size;

    fprintf(stderr, "Cannot determine size of %s: %s\n",
            filename, strerror(errno));

    return -1;
}

Sur les systèmes 32 bits, vous devez le compiler avec l'option -D_FILE_OFFSET_BITS=64 sinon off_t ne pourra contenir que des valeurs allant jusqu'à 2 Go. Consultez la section "Utilisation de LFS" de Support des gros fichiers sous Linux pour les détails.

Answer 2

N'utilisez pas int . Les fichiers de plus de 2 gigaoctets sont monnaie courante de nos jours.

N'utilisez pas unsigned int . Les fichiers de plus de 4 gigaoctets sont courants, tout comme certaines saletés un peu moins courantes.

IIRC la bibliothèque standard définit off_t comme un entier 64 bits non signé, ce qui est ce que tout le monde devrait utiliser. Nous pourrons le redéfinir en 128 bits dans quelques années, lorsque nous commencerons à avoir des fichiers de 16 exaoctets.

Si vous êtes sous Windows, vous devriez utiliser GetFileSizeEx - il utilise en fait un entier 64 bits signé, donc ils vont commencer à avoir des problèmes avec des fichiers de 8 exabytes. Stupide Microsoft ! :-)

Answer 3

La solution de Matt devrait fonctionner, sauf qu'il s'agit de C++ au lieu de C, et que le tell initial ne devrait pas être nécessaire.

unsigned long fsize(char* file)
{
    FILE * f = fopen(file, "r");
    fseek(f, 0, SEEK_END);
    unsigned long len = (unsigned long)ftell(f);
    fclose(f);
    return len;
}

J'ai aussi corrigé votre accolade pour vous ;)

Mise à jour : Ce n'est pas vraiment la meilleure solution. Elle est limitée aux fichiers de 4GB sous Windows et elle est probablement plus lente que l'utilisation d'un appel spécifique à la plateforme comme GetFileSizeEx o stat64 .

Answer 4

**Ne faites pas cela ( Pourquoi ? ) :

Je cite le document standard C99 que j'ai trouvé en ligne : "Définir l'indicateur de position de fichier à la fin du fichier, comme avec fseek(file, 0, SEEK_END) a un comportement non défini pour un flux binaire (en raison de la possibilité de caractères nuls à la fin) ou pour tout flux dont le codage dépend de l'état et qui ne se termine pas assurément dans l'état de décalage initial**.

Changez la définition en int pour que les messages d'erreur puissent être transmis, puis utilisez fseek() y ftell() pour déterminer la taille du fichier.

int fsize(char* file) {
  int size;
  FILE* fh;

  fh = fopen(file, "rb"); //binary mode
  if(fh != NULL){
    if( fseek(fh, 0, SEEK_END) ){
      fclose(fh);
      return -1;
    }

    size = ftell(fh);
    fclose(fh);
    return size;
  }

  return -1; //error
}

Answer 5

Si vous êtes d'accord pour utiliser la bibliothèque std c :

#include <sys/stat.h>
off_t fsize(char *file) {
    struct stat filestat;
    if (stat(file, &filestat) == 0) {
        return filestat.st_size;
    }
    return 0;
}