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

No use int. Los archivos de más de 2 gigabytes de tamaño son comunes como la suciedad en estos días

No use unsigned int. Los archivos de más de 4 gigabytes de tamaño son comunes como algunos dirt

IIRC la biblioteca estándar define off_t como un entero de 64 bits sin signo, que es lo que todos deberían usar. Podemos redefinir eso para que sea de 128 bits en unos pocos años cuando comencemos a tener archivos de 16 exabytes por ahí.

Si estás en Windows, deberías usar GetFileSizeEx - it en realidad utiliza un entero de 64 bits firmado, por lo que comenzará a golpear problemas con 8 archivos exabyte. ¡Tonto Microsoft! :-)

La solución de Matt debería funcionar, excepto que es C++ en lugar de C, y el tell inicial 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;
}

También arreglé tu corsé para ti. ;)

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

* * No hagas esto ( ¿por qué?):

Citando el documento estándar de C99 que encontré en línea: "Establecer el indicador de posición del archivo al final del archivo, como con fseek(file, 0, SEEK_END), tiene un comportamiento indefinido para una secuencia binaria (debido a posibles caracteres nulos finales) o para cualquier secuencia con codificación dependiente del estado que no termine seguramente en el estado de cambio inicial.**

Cambie la definición a int para que los mensajes de error se puedan transmitir, y luego use fseek () y ftell () para determinar el tamaño del 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
}

Si está de acuerdo con usar la biblioteca 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;
}

Y si está construyendo una aplicación de Windows, use la API GetFileSizeEx ya que la E/S del archivo CRT es desordenada, especialmente para determinar la longitud del archivo, debido a las peculiaridades en las representaciones de archivos en diferentes sistemas;)

Una búsqueda rápida en Google encontró un método usando fseek y ftell y un hilo con esta pregunta con respuestas que no se puede hacer solo en C de otra manera.

Puedes usar una biblioteca de portabilidad como NSPR (la biblioteca que alimenta Firefox) o comprobar su implementación (bastante peluda).

Utilicé 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);

Aquí hay una función simple y limpia que devuelve el tamaño del archivo.

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

Prueba esto {

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

Lo que hace esto es primero, buscar al final del archivo; luego, informar dónde está el puntero del archivo. Por último (esto es opcional) rebobina de nuevo al principio del archivo. Tenga en cuenta que fp debe ser un flujo binario.

File_size contiene el número de bytes que contiene el archivo. Tenga en cuenta que desde (según climits.h) el tipo largo sin signo está limitado a 4294967295 bytes (4 gigabytes) necesitará encontrar un tipo de variable diferente si es probable que trate con archivos más grandes que eso.

Vas a necesitar usar una función de biblioteca para recuperar los detalles de un archivo. Como C es completamente independiente de la plataforma, ¡necesitará informarnos para qué plataforma / sistema operativo está desarrollando!

Mirando la pregunta, ftell puede obtener fácilmente el número de bytes.

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

Puede abrir el archivo, ir a 0 offset relativo desde la parte inferior del archivo con

#define SEEKBOTTOM   2

fseek(handle, 0, SEEKBOTTOM)  

El valor devuelto por fseek es el tamaño del archivo.

No codifiqué en C durante mucho tiempo, pero creo que debería funcionar.