ADBLOCK DEAKTIVIEREN

ADBlock blockiert einige Inhalte auf der Website

ADBlock errore

Wie beurteilen Sie die Größe einer Datei in C bestimmen?

StackOverflow https://stackoverflow.com/questions/8236

Frage

Wie kann ich die Größe einer Datei herauszufinden, in Bytes?

#include <stdio.h>

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

Lösung

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

Änderungen:

  • der Dateiname Argument Hergestellt ein const char.
  • die struct stat Definition korrigiert, der die Variablennamen fehlt.
  • Returns -1 auf Fehler statt 0, die für eine leere Datei nicht eindeutig wäre. off_t ist ein signierter Typ so ist dies möglich.

Wenn Sie fsize() wollen eine Nachricht auf Fehler zu drucken, können Sie diese verwenden:

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

Auf 32-Bit-Systemen sollten Sie dies mit der Option -D_FILE_OFFSET_BITS=64 kompilieren, sonst off_t werden nur Werte halten bis zu 2 GB. Siehe "Mit LFS" Abschnitt Large File Support rel="noreferrer">.

ANDERE TIPPS

Verwenden Sie int nicht. Dateien über 2 Gigabyte groß sind häufig wie Schmutz in diesen Tagen

Verwenden Sie unsigned int nicht. Dateien über 4 Gigabyte groß sind häufig als ein etwas weniger gemeinsamer Schmutz

IIRC die Standardbibliothek definiert off_t als unsigned 64-Bit-Integer, das, was jeder sollte werden. Wir können neu definieren, dass 128 Bits in ein paar Jahren zu sein, wenn wir 16 Exabyte Dateien beginnen mit rumhängen.

Wenn Sie auf Fenster sind, dann sollten Sie GetFileSizeEx - es tatsächlich verwendet eine 64-Bit-integer unterzeichnet, so werden sie schlagen Probleme mit 8 Exabyte Dateien starten. Foolish Microsoft! : -)

Matts Lösung sollte funktionieren, mit der Ausnahme, dass es C ++ anstelle von C, und das anfänglichen tell sollte nicht notwendig sein.

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

Fixed Ihre Klammer auch für Sie. ;)

Update: Das ist nicht wirklich die beste Lösung. Es ist auf 4 GB-Dateien unter Windows und es ist wahrscheinlich langsamer als nur einen plattformspezifische Aufruf wie GetFileSizeEx oder stat64 verwenden.

** dies nicht tun ( warum ):

  

Zitiert der C99-Standard doc, die ich online gefunden: „Einstellen der Dateipositionszeiger auf End-of-Datei, wie mit fseek (Datei, 0, SEEK_END) hat Verhalten für einen binären Strom Nicht spezifiziert (wegen der möglichen Nachlauf null Zeichen) oder für jede Stream mit zustandsabhängigen Codierung, die nicht sicher in dem Anfangsschaltzustand beenden ist. **

die Definition ändern, so dass Fehlermeldungen übertragen werden, in int werden, und verwenden Sie dann fseek () und ftell (), um die Dateigröße zu bestimmen.

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
}

Wenn Sie in Ordnung mit der Verwendung der std C-Bibliothek:

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

POSIX

Der POSIX Standard hat seine eigene Methode Dateigröße zu erhalten.
Fügen Sie den sys/stat.h Header, um die Funktion zu verwenden.

Überblick

  • Get Statistikdatei mit stat(3) .
  • Rufen Sie die st_size Eigenschaft.

Beispiele

Hinweis : Er begrenzt die Größe 4GB. Wenn dies nicht das Dateisystem Fat32 dann die 64-Bit-Version verwenden!

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

Das ANSI C nicht direkt bietet die Möglichkeit, die Länge der Datei zu bestimmen.
Wir müssen unseren Geist verwenden. Vorerst werden wir den Such Ansatz verwenden!

Überblick

Beispiel

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

Wenn die Datei stdin oder ein Rohr. POSIX, ANSI C wird nicht funktionieren.   
  Es wird gehen Rückkehr 0, wenn die Datei ein Rohr oder stdin ist.

     

Meinung :   Sie sollten stattdessen POSIX Standard verwenden. Da hat es 64-Bit-Unterstützung.

Und wenn Sie eine Windows-Anwendung Gebäude sind, verwenden Sie die GetFileSizeEx API als CRT Datei-I / O ist etwas chaotisch, insbesondere für Dateilänge Bestimmung aufgrund Eigentümlichkeiten in Dateidarstellungen auf verschiedenen Systemen;)

Eine schnelle Suche in Google gefunden ein Verfahren fseek mit und ftell und ein Gewinde mit dieser Frage mit Antworten, die es nicht auf eine andere Weise in nur C durchgeführt werden.

Sie könnten eine Portabilität Bibliothek verwenden wie NSPR (die Bibliothek, die Kräfte Firefox) oder überprüfen seine Umsetzung (eher behaarte).

Ich habe diesen Satz von Code die Dateilänge zu finden.

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

Versuchen Sie, diese -

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

Was das bedeutet zunächst, bis zum Ende der Datei suchen; dann melden, wenn der Dateizeiger ist. Schließlich (dies ist optional) es spult an den Anfang der Datei zurück. Beachten Sie, dass fp sollte ein binärer Strom sein.

file_size enthält die Anzahl von Bytes, die Datei enthält. Beachten Sie, dass da (nach climits.h) die unsigned long Typ 4294967295 Bytes begrenzt ist (4 Gigabyte) Sie benötigen einen anderen Variablentyp zu finden, wenn Sie mit Dateien umgehen größer als die wahrscheinlich sind.

Hier ist eine einfache und saubere Funktion, die die Dateigröße zurück.

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 
}

Sie gehen zu müssen, eine Library-Funktion verwenden, um die Details einer Datei abzurufen. Als C vollständig plattformunabhängig ist, Sie gehen, uns wissen zu müssen informieren, welche Plattform / Betriebssystem Sie entwickeln für!

auf die Frage sucht, ftell kann leicht die Anzahl von Bytes bekommen.

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

Sie können die Datei öffnen, gehen auf 0 vom Ende der Datei versetzt mit

#define SEEKBOTTOM   2

fseek(handle, 0, SEEKBOTTOM)  

der Wert von fseek zurückgegeben wird, ist die Größe der Datei.

habe ich keinen Code in C für eine lange Zeit, aber ich denke, es sollte funktionieren.

Licensed under: CC-BY-SA with attribution
Not affiliated with StackOverflow