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

Question

Comment puis-je déterminer la taille d'un fichier, en octets?

#include <stdio.h>

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

Answer 1

Basé sur NilObject code:

#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:

• Faites l'argument filename un const char.
• Correction de l' struct stat définition, qui était à côté le nom de la variable.
• Retourne -1 en cas d'erreur au lieu de 0, qui serait ambigu pour un fichier vide. off_t est un type signé, donc c'est possible.

Si vous voulez fsize() pour imprimer un message 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 seules les valeurs de jusqu'à 2 GO.Voir la section "Utilisation de l'EFT" section de Grand Support des Fichiers sous Linux pour plus de détails.

Answer 2

Ne pas utiliser de int.Les fichiers de plus de 2 gigaoctets sont communs comme la saleté de ces jours

Ne pas utiliser de unsigned int.Les fichiers de plus de 4 gigaoctets sont communs comme un petit peu-moins-de la commune de la saleté

Autant que je me souvienne de la bibliothèque standard définit off_t comme un entier non signé entier de 64 bits, qui est ce que tout le monde devrait être en utilisant.On peut redéfinir qui à 128 bits dans quelques années, quand nous commençons à avoir 16 exabyte fichiers qui traînent.

Si vous êtes sur windows, vous devez utiliser GetFileSizeEx - en fait, il utilise signé un entier de 64 bits, donc ils vont commencer à frapper des problèmes avec 8 exabyte fichiers.Folles De Microsoft!:-)

Answer 3

Matt solution devrait fonctionner, sauf que c'est du C++ au lieu de C, et l'initiale dire 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;
}

Fixe votre corset pour vous, trop.;)

Mise à jour:Ce n'est pas vraiment la meilleure solution.Elle est limitée à 4 go de fichiers sur Windows et il est probable plus lent que simplement en utilisant une plate-forme d'appel spécifique, comme GetFileSizeEx ou stat64.

Answer 4

**Ne pas faire ceci (pourquoi?):

Citant le standard C99 doc que j'ai trouvé en ligne:"Réglage de la position de l'indicateur de fin de fichier fseek(fichier, 0, SEEK_END), a un comportement indéfini pour un flux binaire (en raison de la possible fuite des caractères null) ou pour n'importe quel flux, dépendant de l'état de l'encodage qui n'est pas assurément la fin de l'état de décalage initial.**

Modifier la définition de l'int de sorte que les messages d'erreur peuvent être transmises, et ensuite utiliser fseek() et 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 bien avec l'aide de la std c de la bibliothèque:

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

Answer 6

POSIX

L' POSIX la norme a sa propre méthode pour obtenir la taille du fichier.
Inclure l' sys/stat.h l'en-tête de la fonction.

Synopsis

• Obtenir le fichier de statistiques à l'aide stat(3).
• Obtenir le st_size de la propriété.

Exemples

Note:Il limite la taille de 4GB.Si ce n' Fat32 système de fichiers puis utilisez la version 64 bits!

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

int main(int argc, char** argv)
{
    struct stat info;
    stat(argv[1], &info);

    // 'st' is an acronym of 'stat'
    printf("%s: size=%ld\n", argv[1], info.st_size);
}

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

int main(int argc, char** argv)
{
    struct stat64 info;
    stat64(argv[1], &info);

    // 'st' is an acronym of 'stat'
    printf("%s: size=%ld\n", argv[1], info.st_size);
}

ANSI C (standard)

L' C ANSI ne fournit directement la façon de déterminer la longueur du fichier.
Nous allons utiliser notre esprit.Pour l'instant, nous allons utiliser la recherche approche!

Synopsis

• Chercher le fichier à la fin à l'aide de fseek(3).
• Obtenir la position actuelle à l'aide de ftell(3).

Exemple

#include <stdio.h>

int main(int argc, char** argv)
{
    FILE* fp = fopen(argv[1]);
    int f_size;

    fseek(fp, 0, SEEK_END);
    f_size = ftell(fp);
    rewind(fp); // to back to start again

    printf("%s: size=%ld", (unsigned long)f_size);
}

Si le fichier est stdin ou un tuyau. POSIX, ANSI C ne fonctionne pas.
Il va revenir 0 si le fichier est un tube ou d'une stdin.

Avis:Vous devez utiliser POSIX standard à la place.Parce qu'il a 64bit de soutien.

Answer 7

Et si vous êtes la construction d'une application Windows, utilisez l' GetFileSizeEx API CRT fichier I/O est en désordre, en particulier pour la détermination de la longueur du fichier, en raison des particularités dans les représentations de fichiers sur des systèmes différents ;)

Answer 8

Une rapide recherche dans Google trouve une méthode à l'aide de fseek et ftell et un fil avec cette question avec des réponses qu'il ne peut pas être fait en C d'une autre manière.

Vous pouvez utiliser une portabilité de la bibliothèque comme NSPR (la bibliothèque des pouvoirs Firefox) ou chèque sa mise en œuvre (plutôt poilu).

Answer 9

J'ai utilisé ce jeu de code pour trouver la longueur du fichier.

//opens a file with a file descriptor
FILE * i_file;
i_file = fopen(source, "r");

//gets a long from the file descriptor for fstat
long f_d = fileno(i_file);
struct stat buffer;
fstat(f_d, &buffer);

//stores file size
long file_length = buffer.st_size;
fclose(i_file);

Answer 10

Essayez ceci --

fseek(fp, 0, SEEK_END);
unsigned long int file_size = ftell(fp);
rewind(fp);

Ce que cela fait, c'est d'abord, chercher à la fin du fichier;ensuite, le rapport où le pointeur de fichier est.Enfin (c'est facultatif) il rembobine retour au début du fichier.Notez que fp doit être un flux binaire.

taille_fichier contient le nombre d'octets que contient le fichier.A noter que depuis (selon climits.h) le type unsigned long type est limitée à 4294967295 octets (4 gigaoctets), vous aurez besoin de trouver un autre type de variable si vous êtes susceptible de traiter des fichiers de plus que cela.

Answer 11

Voici un simple et propre, fonction qui renvoie la taille du fichier.

long get_file_size(char *path)
{
    FILE *fp;
    long size = -1;
    /* Open file for reading */
    fp = fopen(path, "r");
    fseek(fp, 0, SEEK_END);
    size = ftell(fp); 
    fp.close();
    return 
}

Answer 12

Vous allez avoir besoin d'utiliser une fonction de la bibliothèque pour récupérer les informations d'un fichier.Comme C est complètement indépendant de la plateforme, vous allez avoir besoin pour nous permettre de savoir quel système d'exploitation / plateforme que vous êtes en développement pour!

Answer 13

L'examen de la question, ftell pouvez facilement obtenir le nombre d'octets.

  long size ;
  size = ftell(FILENAME);
  printf("total size is %ld bytes",size);

Answer 14

Vous pouvez ouvrir le fichier, passez à l'0 décalage par rapport à partir de la fin du fichier avec

#define SEEKBOTTOM   2

fseek(handle, 0, SEEKBOTTOM)  

la valeur renvoyée par fseek est la taille du fichier.

Je n'ai pas de code en C pour un temps long, mais je pense que cela devrait fonctionner.