Wie funktioniert Fread wirklich?

Die Erklärung von fread ist wie folgt:

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

Die Frage ist: Gibt es einen Unterschied in der Leseleistung von zwei solchen Anrufen? fread:

char a[1000];

1. fread(a, 1, 1000, stdin);
2. fread(a, 1000, 1, stdin);

Wird es gelesen 1000 Bytes auf einmal jedes Mal?

Es kann einen Unterschied in der Leistung geben oder auch nicht. Es gibt einen Unterschied in der Semantik.

fread(a, 1, 1000, stdin);

versucht, 1000 Datenelemente zu lesen, von denen jedes 1 Byte lang ist.

fread(a, 1000, 1, stdin);

versucht, 1 Datenelement zu lesen, das 1000 Bytes lang ist.

Sie sind anders, weil fread() gibt die Anzahl der Datenelemente zurück, die gelesen werden konnten, nicht die Anzahl der Bytes. Wenn es das Dateiende (oder eine Fehlerbedingung) erreicht, bevor es die vollen 1000 Bytes gelesen hat, muss die erste Version genau angeben, wie viele Bytes es gelesen hat; die zweite schlägt einfach fehl und gibt 0 zurück.

In der Praxis wird wahrscheinlich nur eine untergeordnete Funktion aufgerufen, die versucht, 1000 Bytes zu lesen, und angibt, wie viele Bytes tatsächlich gelesen wurden. Bei größeren Lesevorgängen werden möglicherweise mehrere Aufrufe auf niedrigerer Ebene ausgeführt. Die Berechnung des zurückzugebenden Werts von fread() ist anders, aber der Rechenaufwand ist trivial.

Es kann einen Unterschied geben, ob die Implementierung vor dem Versuch, die Daten zu lesen, feststellen kann, dass nicht genügend Daten zum Lesen vorhanden sind. Wenn Sie beispielsweise aus einer 900-Byte-Datei lesen, liest die erste Version alle 900 Bytes und gibt 900 zurück, während die zweite Version sich möglicherweise nicht die Mühe macht, etwas zu lesen. In beiden Fällen wird die Dateipositionsanzeige um die Zahl von erhöht Figuren erfolgreich gelesen, dh 900.

Aber im Allgemeinen sollten Sie wahrscheinlich wählen, wie Sie es aufrufen, basierend auf den Informationen, die Sie daraus benötigen. Lesen Sie ein einzelnes Datenelement, wenn ein teilweises Lesen nicht besser ist, als gar nichts zu lesen. Lesen Sie in kleineren Teilen, wenn partielle Lesevorgänge nützlich sind.

Entsprechend die Spezifikationkönnen die beiden von der Implementierung unterschiedlich behandelt werden.

Wenn Ihre Datei kleiner als 1000 Byte ist, fread(a, 1, 1000, stdin) (Lesen von 1000 Elementen mit jeweils 1 Byte) kopiert weiterhin alle Bytes bis EOF. Andererseits ist das Ergebnis von fread(a, 1000, 1, stdin) (Lesen Sie 1 1000-Byte-Element) gespeichert in a ist nicht angegeben, da nicht genügend Daten vorhanden sind, um das Lesen des „ersten“ (und einzigen) 1000-Byte-Elements abzuschließen.

Natürlich können einige Implementierungen das „partielle“ Element immer noch in so viele Bytes wie nötig kopieren.

Das wäre das Implementierungsdetail. In glibc sind die beiden in der Leistung identisch, da sie im Grunde wie folgt implementiert sind (Ref http://sourceware.org/git/?p=glibc.git;a=blob;f=libio/iofread.c):

size_t fread (void* buf, size_t size, size_t count, FILE* f)
{
    size_t bytes_requested = size * count;
    size_t bytes_read = read(f->fd, buf, bytes_requested);
    return bytes_read / size;
}

Beachten Sie, dass C und POSIX Standard garantiert keine vollständige Objektgröße size muss jedes Mal gelesen werden. Wenn ein vollständiges Objekt nicht gelesen werden kann (z stdin hat nur 999 Bytes, aber Sie haben angefordert size == 1000), wird die Datei in einem unbestimmten Zustand belassen (C99 §7.19.8.1/2).

Bearbeiten: Siehe die anderen Antworten zu POSIX.

fread Anrufe getc im Inneren. in Minix Anzahl getc heißt ist einfach size*nmemb also wie oft getc angerufen wird, hängt von der ab Produkt von diesen beiden. Also beides fread(a, 1, 1000, stdin) und fread(a, 1000, 1, stdin) werde rennen getc 1000=(1000*1) Mal. Hier ist die einfache Implementierung von fread von Minix

size_t fread(void *ptr, size_t size, size_t nmemb, register FILE *stream){
register char *cp = ptr;
register int c;
size_t ndone = 0;
register size_t s;

if (size)
    while ( ndone < nmemb ) {
    s = size;
    do {
        if ((c = getc(stream)) != EOF)
            *cp++ = c;
        else
            return ndone;
    } while (--s);
    ndone++;
}

return ndone;
}

Möglicherweise gibt es keinen Leistungsunterschied, aber diese Aufrufe sind nicht identisch.

• fread gibt die Anzahl der gelesenen Elemente zurück, sodass diese Aufrufe unterschiedliche Werte zurückgeben.
• Wenn ein Element nicht vollständig gelesen werden kann, ist sein Wert unbestimmt:

Wenn ein Fehler auftritt, ist der resultierende Wert des Dateipositionsindikators für den Stream unbestimmt. Wenn ein Teilelement gelesen wird, ist sein Wert unbestimmt. (ISO/IEC 9899:TC2 7.19.8.1)

Es gibt keinen großen Unterschied in der glibc-Implementierung, das einfach die Elementgröße mit der Anzahl der Elemente multipliziert, um zu bestimmen, wie viele Bytes gelesen werden sollen, und die gelesene Menge am Ende durch die Elementgröße dividiert. Aber die Version, die eine Elementgröße von 1 angibt, wird Ihnen immer die richtige Anzahl gelesener Bytes mitteilen. Wenn Sie jedoch nur auf vollständig gelesene Elemente einer bestimmten Größe Wert legen, erspart Ihnen die Verwendung der anderen Form eine Division.

Noch eine Satzform http://pubs.opengroup.org/onlinepubs/000095399/functions/fread.html es ist nicht möglich

Die fread()-Funktion liest in das Array, auf das ptr zeigt, bis zu nitems Elementen, deren Größe durch size in Bytes angegeben ist, aus dem Stream, auf den stream zeigt. Für jedes Objekt sollen Größenaufrufe an die Funktion fgetc() erfolgen und die Ergebnisse gespeichert werdenin der gelesenen Reihenfolge, in einem Array von unsigned char, das genau das Objekt überlagert.

Kurz gesagt, in beiden Fällen wird mit fgetc() auf die Daten zugegriffen…!

Ich wollte die Antworten hier verdeutlichen. fread führt gepufferte IO durch. Die tatsächlichen Leseblockgrößen, die fread verwendet, werden durch die verwendete C-Implementierung bestimmt.

Alle modernen C-Bibliotheken haben die gleiche Leistung mit den beiden Aufrufen:

fread(a, 1, 1000, file);
fread(a, 1000, 1, file);

Sogar sowas wie:

for (int i=0; i<1000; i++)
  a[i] = fgetc(file)

Sollte zu den gleichen Festplattenzugriffsmustern führen, obwohl fgetc aufgrund von mehr Aufrufen in die Standard-c-Bibliotheken und in einigen Fällen der Notwendigkeit einer Festplatte zur Durchführung zusätzlicher Suchvorgänge langsamer wäre, die andernfalls wegoptimiert worden wären.

Zurück zum Unterschied zwischen den beiden Formen von Fread. Ersteres gibt die tatsächliche Anzahl gelesener Bytes zurück. Letzteres gibt 0 zurück, wenn die Dateigröße kleiner als 1000 ist, ansonsten 1. In beiden Fällen würde der Puffer mit den gleichen Daten gefüllt werden, dh dem Inhalt der Datei bis zu 1000 Bytes.

Im Allgemeinen möchten Sie wahrscheinlich den 2. Parameter (Größe) auf 1 gesetzt lassen, damit Sie die Anzahl der gelesenen Bytes erhalten.