¿Cómo se puede determinar el tamaño de un archivo en C?

Question

¿Cómo puedo averiguar el tamaño de un archivo en bytes?

#include <stdio.h>

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

Answer 1

Basado en NilObject del código:

#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; 
}

Cambios:

• Hecho el argumento de nombre de archivo de un const char.
• Se ha corregido el struct stat de la definición, que faltaba el nombre de la variable.
• Devuelve -1 en caso de error en lugar de 0, que sería ambigua para un archivo vacío. off_t es una carta firmada tipo así que esto es posible.

Si quieres fsize() para imprimir un mensaje de error, puede utilizar esto:

#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;
}

En sistemas de 32 bits, se deben compilar esto con la opción de -D_FILE_OFFSET_BITS=64, que , de lo contrario off_t sólo contendrá los valores de hasta 2 GB.Consulte la "Uso de EFT" de la sección de Soporte de Archivos grandes en Linux para obtener más detalles.

Answer 2

No uso int.Archivos de más de 2 gigabytes de tamaño son comunes, ya que la suciedad en estos días

No uso unsigned int.Archivos de más de 4 gigabytes de tamaño son comunes como algunos ligeramente menos común de tierra

IIRC la biblioteca estándar define off_t como un entero de 64 bits con signo, que es lo que cada uno debe usar.Podemos redefinir la que para ser de 128 bits en un par de años, cuando empezamos a tener 16 exabyte archivos de colgar alrededor.

Si estás en windows, usted debe utilizar GetFileSizeEx - que en realidad se utiliza firmado un entero de 64 bits, así que voy a empezar a golpear problemas con 8 exabyte archivos.Tonto De Microsoft!:-)

Answer 3

Matt la solución de trabajo, salvo que C++ en lugar de C, y la inicial de decirle no debería ser necesario.

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;
}

Fija la abrazadera para usted, también.;)

Actualización:Esto no es realmente la mejor solución.Está limitado a 4 gb de archivos en Windows y es probablemente más lento que usar una plataforma específica llamada como GetFileSizeEx o stat64.

Answer 4

** * * * No hacer esto (lospor qué?):

Citando el estándar C99 doc que he encontrado en internet:"Ajuste de la posición de archivo indicador de fin de archivo, como con el fseek(archivo, 0, SEEK_END), tiene un comportamiento indefinido para un flujo binario (debido a la posible null final de caracteres) o para cualquier corriente con el estado-dependiente de la codificación que no duda de final en la fase inicial del cambio de estado.**

Cambiar la definición de int, de modo que los mensajes de error pueden ser transmitidos y, a continuación, utilizar el fseek() y ftell() para determinar el tamaño de archivo.

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 estás bien con el uso de la ets de la biblioteca c:

#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

El POSIX estándar tiene su propio método para obtener el tamaño del archivo.
Incluir la sys/stat.h encabezado de utilizar la función.

Sinopsis

• Obtener el archivo de estadísticas de uso de stat(3).
• Obtener el st_size de la propiedad.

Ejemplos

Nota:Limita el tamaño de 4GB.Si no Fat32 sistema de archivos, a continuación, utilizar la versión de 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);
}

En ANSI C (estándar)

El ANSI C directamente no proporciona la manera de determinar la longitud del archivo.
Tendremos que utilizar nuestra mente.Por ahora, vamos a utilizar el buscar el enfoque!

Sinopsis

• Buscar el archivo al final el uso de fseek(3).
• Obtener la posición actual utilizando ftell(3).

Ejemplo

#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 el archivo es stdin o una tubería. POSIX, ANSI C no, no funcionará.
Se va volver 0 si el archivo es un tubo o stdin.

Opinión:Usted debe utilizar POSIX estándar en su lugar.Porque, tiene 64 bits de apoyo.

Answer 7

Y si usted está construyendo una aplicación de Windows, utilice el GetFileSizeEx API como CRT e/S de archivo es complicado, especialmente para la determinación de la longitud del archivo, debido a las peculiaridades en el archivo de representaciones en diferentes sistemas ;)

Answer 8

Una búsqueda rápida en Google que se encuentra un método que utiliza el fseek y ftell y un hilo con esta pregunta con respuestas que no puede hacerse sólo en C de otra manera.

Usted podría utilizar una portabilidad de la biblioteca como NSPR (la biblioteca que los poderes de Firefox) o de verificación su aplicación (más bien peludo).

Answer 9

He utilizado este conjunto de código para encontrar la longitud del archivo.

//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

Pruebe esto ...

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

Lo que esto hace es, en primer lugar, buscar hasta el final del archivo;a continuación, informe donde el puntero de archivo es.Por último (esto es opcional) se rebobina y vuelve al principio del archivo.Tenga en cuenta que fp debe ser una secuencia binaria.

file_size contiene el número de bytes que contiene el archivo.Tenga en cuenta que debido a que (según climits.h) el unsigned long tipo se limita a 4294967295 bytes (4 gigabytes) usted tendrá que encontrar un diferente tipo de variable si vas a tratar con archivos de más que eso.

Answer 11

He aquí una sencilla y limpia función que devuelve el tamaño del archivo.

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

Vas a necesitar el uso de una función de biblioteca para recuperar los detalles de un archivo.Como C es completamente independiente de la plataforma, usted va a necesitar para hacernos saber lo que la plataforma / sistema operativo que está en desarrollo para!

Answer 13

Analizando la cuestión, ftell puede conseguir fácilmente el número de bytes.

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

Answer 14

Puede abrir el archivo, vaya a 0 desplazamiento relativo de la parte inferior del archivo con

#define SEEKBOTTOM   2

fseek(handle, 0, SEEKBOTTOM)  

el valor devuelto desde el fseek es el tamaño del archivo.

Yo no código en C para un largo tiempo, pero creo que debería funcionar.