tamaño - leer palabras de un archivo en c

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

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

#include <stdio.h> unsigned int fsize(char* file){ //what goes here? }

** No hagas esto ( why? ):

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

Cambie la definición a int para que se puedan transmitir los mensajes de error, 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 }

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

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

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

Basado en el código de NilObject:

#include <sys/stat.h> off_t fsize(const char *filename) { struct stat st; if (stat(filename, &st) == 0) return st.st_size; return -1; }

Cambios:

Hizo que el argumento del nombre de archivo fuera un const char .
Se corrigió la definición de struct stat , a la que le faltaba el nombre de la variable.
Devuelve -1 en error en lugar de 0 , lo que sería ambiguo para un archivo vacío. off_t es un tipo firmado así que esto es posible.

Si desea que fsize() imprima un mensaje en caso de error, puede usar esto:

#include <sys/stat.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, debe compilar esto con la opción -D_FILE_OFFSET_BITS=64 , de lo contrario, off_t solo tendrá valores de hasta 2 GB. Consulte la sección "Uso de LFS" de Soporte de archivos grandes en Linux para obtener más información.

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

Se arregló tu llave para ti también. ;)

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

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

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

No use unsigned int Los archivos de más de 4 gigabytes de tamaño son comunes debido a la suciedad poco común

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 que sea de 128 bits en unos pocos años cuando comencemos a tener 16 archivos exabyte dando vueltas.

Si está en Windows, debe usar GetFileSizeEx ; en realidad, usa un número entero de 64 bits con signo, por lo que comenzarán a resolver problemas con 8 archivos exabyte. ¡Tonto Microsoft! :-)

Prueba esto --

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

Lo que esto hace es primero, buscar hasta el final del archivo; luego, informe dónde está el puntero del archivo. Por último (esto es opcional) rebobina al principio del archivo. Tenga en cuenta que fp debe ser una secuencia binaria.

file_size contiene la cantidad de bytes que contiene el archivo. Tenga en cuenta que, dado que (de acuerdo con 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 trabaje con archivos más grandes que eso.

Puede abrir el archivo, vaya 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.

Si está bien con el uso de la biblioteca estándar c:

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

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

Puede usar una biblioteca de portabilidad como NSPR (la biblioteca que impulsa Firefox) o verificar su implementación (más bien peluda).

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

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