Come posso capire la dimensione di un file, in byte?

#include <stdio.h>

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

Basato sul codice di 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; 
}

I cambiamenti:

• Crea l'argomento nome file a const char.
• Correzione della struct statdefinizione, in cui mancava il nome della variabile.
• Restituisce -1in caso di errore anziché 0, il che sarebbe ambiguo per un file vuoto. off_tè un tipo firmato quindi questo è possibile.

Se si desidera fsize()stampare un messaggio in caso di errore, è possibile utilizzare questo:

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

Sui sistemi a 32 bit è necessario compilarlo con l'opzione -D_FILE_OFFSET_BITS=64, altrimenti off_tconterrà solo valori fino a 2 GB. Per i dettagli, consultare la sezione "Uso di LFS" del supporto per file di grandi dimensioni in Linux .

Non usare int. I file di dimensioni superiori a 2 gigabyte sono comuni come sporcizia in questi giorni

Non usare unsigned int. I file di dimensioni superiori a 4 gigabyte sono comuni come sporcizia leggermente meno comune

IIRC la libreria standard definisce off_tcome un intero a 64 bit senza segno, che è quello che tutti dovrebbero usare. Possiamo ridefinirlo in 128 anni in pochi anni quando iniziamo ad avere 16 file exabyte in giro.

Se sei su Windows, dovresti usare GetFileSizeEx : in realtà utilizza un intero con segno a 64 bit, quindi inizieranno a colpire i problemi con 8 file exabyte. Microsoft sciocca! :-)

La soluzione di Matt dovrebbe funzionare, tranne per il fatto che è C ++ anziché C, e la spiegazione iniziale non dovrebbe essere necessaria.

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

Risolto il problema anche con te. ;)

Aggiornamento: questa non è davvero la soluzione migliore. È limitato a file da 4 GB su Windows ed è probabilmente più lento del semplice utilizzo di una chiamata specifica della piattaforma come GetFileSizeExo stat64.

** Non farlo ( perché? ):

Citando il documento standard C99 che ho trovato online: "L'impostazione dell'indicatore di posizione del file su end-of-file, come con fseek(file, 0, SEEK_END), ha un comportamento indefinito per un flusso binario (a causa di possibili caratteri null finali) o per qualsiasi flusso con codifica dipendente dallo stato che sicuramente non termina nello stato iniziale del turno. **

Modificare la definizione in int in modo che i messaggi di errore possano essere trasmessi, quindi utilizzare fseek()e ftell()per determinare la dimensione del file.

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
}

POSIX

Lo standard POSIX ha il suo metodo per ottenere le dimensioni del file.
Includi l' sys/stat.hintestazione per usare la funzione.

Sinossi

• Ottieni statistiche sui file utilizzando stat(3).
• Ottieni la st_sizeproprietà.

Esempi

Nota : limita la dimensione a 4GB. Se non il Fat32filesystem, usa la versione a 64 bit!

#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' ANSI C non fornisce direttamente il modo per determinare la lunghezza del file.
Dovremo usare la nostra mente. Per ora, useremo l'approccio seek!

Sinossi

• Cerca il file fino alla fine usando fseek(3).
• Ottieni la posizione corrente usando ftell(3).

Esempio

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

Se il file è stdino una pipe. POSIX, ANSI C non funzionerà.
Restituirà 0se il file è una pipe o stdin.

Opinione : si dovrebbe usare invece lo standard POSIX . Perché, ha il supporto a 64 bit.

E se stai creando un'app di Windows, usa l' API GetFileSizeEx poiché l'I / O dei file CRT è disordinato, soprattutto per determinare la lunghezza del file, a causa delle peculiarità nelle rappresentazioni dei file su sistemi diversi;)

Se stai bene usando la libreria 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;
}

Una rapida ricerca su Google ha trovato un metodo che utilizza fseek e ftell e un thread con questa domanda con risposte che non possono essere fatte in C in un altro modo.

È possibile utilizzare una libreria di portabilità come NSPR (la libreria che alimenta Firefox) o verificarne l'implementazione (piuttosto pelosa).

Ho usato questo set di codice per trovare la lunghezza del file.

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

Prova questo --

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

Quello che fa è prima di tutto, cerca fino alla fine del file; quindi, segnala dove si trova il puntatore del file. Infine (questo è facoltativo) si riavvolge all'inizio del file. Si noti che fpdovrebbe essere un flusso binario.

file_size contiene il numero di byte contenuti nel file. Si noti che poiché (in base a climits.h) il tipo lungo senza segno è limitato a 4294967295 byte (4 gigabyte), è necessario trovare un tipo di variabile diverso se si rischia di gestire file di dimensioni maggiori.

Ho una funzione che funziona bene solo con stdio.h. Mi piace molto e funziona molto bene ed è piuttosto conciso:

size_t fsize(FILE *File) {
    size_t FSZ;
    fseek(File, 0, 2);
    FSZ = ftell(File);
    rewind(File);
    return FSZ;
}

Ecco una funzione semplice e pulita che restituisce le dimensioni del file.

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 
}

È possibile aprire il file, andare a 0 offset rispetto dalla parte inferiore del file con

#define SEEKBOTTOM   2

fseek(handle, 0, SEEKBOTTOM)  

il valore restituito da fseek è la dimensione del file.

Non ho programmato il codice in C per molto tempo, ma penso che dovrebbe funzionare.

Osservando la domanda, è ftellpossibile ottenere facilmente il numero di byte.

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