[C] Datei komplett einlesen

[tanis]

Hallo,

ich würde gerne eine Datei komplett einlesen! Das ein Segmentation Fault enthalten ist, ist mir bekannt ist nur ein Beispiel Code. Ich will eine HTML-Datei parsen, derzeit lese ich die Daten Zeilenweise und parse sie sofort Zeile für Zeile. Aus Performance gründen, möchte ich nun allerdings den kompletten Dateiinhalt in ein Array schreiben und dieses Array dann durch parsen. Hab mir jetzt mal gedanken gemacht wie so ein komplett einlesen aussehen könnte. Ich kann mir allerdings nicht vorstellen, das es da keine Funktion gibt die das kann?!

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
    FILE *fd;

    char buffer[1024];
    char *daten;
    char *ret_code;

    if(argc != 2)
        printf("Usage: %s textfile\n",argv[0]);
    else if(argc == 2) {

        fd = fopen(argv[1], "r");
        if(fd) {
            daten = (char *)malloc(sizeof(buffer)+1);
            memset(daten, 0, sizeof(daten));
            do {
                ret_code = fgets(buffer, 1024, fd);
                if(ret_code) {
                    strcat(daten, buffer);
                    daten = (char *)realloc(daten, strlen(daten) + strlen(buffer));
                }
            }while(ret_code);
            fclose(fd);

            printf("<--> Daten:\n %s\n", daten);

        } else
        printf("<--> Error: %s konnte nicht geöffnet werden!\n", argv[1]);
    }
    return 0;
}

Meine Frage ist nun ob es nicht einfacher geht eine ganze Datei komplett einzulesen, wie in Perl zum Beispiel?
PseudoCode - Perl

<FILE>=fopen("text.txt","r");
@daten = <FILE>;
fclose(FILE);

Wäre super wenn mir da jemand helfen könnte!

MfG tanis

[locus vivendi]

Ich kann mir allerdings nicht vorstellen, das es da keine Funktion gibt die das kann?!

In Standard C meines Wissens nicht. Aber du kannst z.B. POSIX mmap verwenden.

[tanis]

Danke erst mal für die schnelle Antwort!

Werd es mal versuchen!

MfG tanis

[tanis]

Hier ist meine Lösung des Problemes: "Eine ganze Datei komplett einlesen!". Ich hoffe es hilft jemandem!

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>

int main(int argc, char *argv[])
{
    FILE *fd;

    char *fdbuf;
    struct stat fdstat;
    long fdpos;
    size_t fdread;


    if(argc != 2)
        printf("Usage: %s textfile\n",argv[0]);
    else {
        fd = fopen(argv[1], "r");
        stat(argv[1],&fdstat);
        if(fd) {
                fdbuf = malloc(fdstat.st_size + 1);
                fdpos = 0;
                fdread = 0;
                fdread = fread(fdbuf + fdpos, sizeof(char), fdstat.st_size - fdpos, fd);
                fdpos += fdread;
                fdbuf[fdpos] = '\0';
                fclose(fd);
                printf("%s\n",fdbuf);
        } else
            printf("<--> Error: %s konnte nicht geöffnet werden!\n", argv[1]);
    }
    return 0;
}

MfG tanis

[locus vivendi]

Wobei "stat" wiederum auch nicht in C ist, sondern z.B. in POSIX.

[locus vivendi]

Ach nochwas: Du bist vermutlich besser dran, wenn du die Fehlerbehandlung vervollständigst...

[tanis]

Danke hast recht, hab ich übersehen ok die version sollte nun vollständig sein!

#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>

int main(int argc, char *argv[])
{
    FILE *fd;

    char *fdbuf;
    struct stat fdstat;
    long fdpos;
    size_t fdread;
    int stat_res;


    if(argc != 2)
        printf("Usage: %s textfile\n",argv[0]);
    else {
        fd = fopen(argv[1], "r");
        stat_res = stat(argv[1],&fdstat);
        if(fd && !stat_res) {
                fdbuf = malloc(fdstat.st_size + 1);
                fdpos = 0;
                fdread = 0;
                fdread = fread(fdbuf + fdpos, sizeof(char), fdstat.st_size - fdpos, fd);
                fdpos += fdread;
                fdbuf[fdpos] = '\0';
                fclose(fd);
                printf("%s\n",fdbuf);
        } else
            printf("<--> Error: %s konnte nicht geöffnet werden!\n", argv[1]);
    }
    return 0;
}

MfG tanis

[locus vivendi]

Danke hast recht, hab ich übersehen ok die version sollte nun vollständig sein!

Ich will ja nicht nerven, aber du solltest auch noch das Ergebnis von malloc überprüfen. Und dann hast du z.B. fdread = 0; fdread = fread(...), drinne, aber ich nehme an, das du noch "aufräumst". Und dann möchte ich dich noch auf einen anderen Punkt hinweisen, der nicht falsch aber überflüssig ist, weil ich glaube, das er fehlendem Wissen entspringt. Du benutzt "sizeof(char)". Das musst du nicht, weil char *immer* die Größe 1 hat. (Oder machst du das aus Dokumentationsgründen?)

[tanis]

Grundsätzlich geb ich dir recht! :-) Auch der Punkt mit dem fehlenden Wissen, bin erst seit ca. 4 Wochen Azubi im Bereich Anwendungsentwicklung! Eine Verständnis frage hab ich allerdings. Ich weis das char ein Byte groß ist, aber gilt das für alle Systeme? Also unter 16Bit, 32Bit, 64Bit und was es da sonst noch so gibt?

MfG tanis

[locus vivendi]

Eine Verständnis frage hab ich allerdings. Ich weis das char ein Byte groß ist, aber gilt das für alle Systeme? Also unter 16Bit, 32Bit, 64Bit und was es da sonst noch so gibt?

Ja, sowohl in C, wie auch in C++, sind char, signed char und unsigned char immer 1 byte groß.

Damit folgt, das anders als im Fernsehquiz behauptet, ein byte mitnichten immer 8 bit groß ist, es kann auch durchaus 47 bit groß sein.

Soweit ich weiß, kann man sich aber darauf verlassen das ein char *mindestens* 8 bit hat, aber ich bin mir nicht ganz sicher.

[tanis]

Danke für die Antwort! :-)

MfG tanis

[dipesh]

Ja, sowohl in C, wie auch in C++, sind char, signed char und unsigned char immer 1 byte groß.

Damit folgt, das anders als im Fernsehquiz behauptet, ein byte mitnichten immer 8 bit groß ist, es kann auch durchaus 47 bit groß sein.

Das würde mich jetzt mal interessieren da ich dem Fernsehquiz bisher immer recht gab. Also, Char = Byte, mit möglichen Werten im Bereich 0 bis 255. Dieser mögliche Bereich ergibt sich aus der Anzahl der möglichen Permutationen bei 8 Bit in einem binären System.
Nun sagst du, daß ein Byte auch 47 Bit groß sein kann. Ich gehe mal davon aus, dass die Zahl zu Stande kommt, durch 8x4-1 (von 8 Bit in einem 16-Bit System, 16 Bit pro Char auf einem 32Bit-System und 48 Bit pro Char auf einem 64Bit-System).
Woher kommt die Dekrementierung um 1 auf einem 64Bit-System? Sind char's auf einem 64Bit-System etwa Vorzeichenbehaftet während sie es vorher nicht waren?
Würde dies nicht bedeuten, dass binäre Kompatibilität zwischen 16, 32 und 64Bit-System nicht möglich ist (deswegen 32Bit-Kompatibilitätsmodus im AMD64? Das würde wenigstens Sinn machen!)?
Warum ist in fast allen C/C++ Dokumentation noch immer die Rede von Char = 8 Bit, wenn aktuell (noch) 32Bit-Systeme de facto Standard sind und somit eigentlich die Rede sein müsste von Char = 16Bit (source-Kompatibilität zu uralten Kassensystemen? Wenn ja, was ist mit 8Bit-Systeme für z.B. Taschenrechner)?

Es würde mich wirklich freuen, wenn jemand mir eine URL reichen könnte auf denen dies erklärt ist (konnte selbst trotz ausgiebiger Suche keine finden) oder selbst ein paar Worte dazu verliert. Danke im voraus!

[locus vivendi]

Zitat von locus vivendi

Ja, sowohl in C, wie auch in C++, sind char, signed char und unsigned char immer 1 byte groß.

Damit folgt, das anders als im Fernsehquiz behauptet, ein byte mitnichten
immer 8 bit groß ist, es kann auch durchaus 47 bit groß sein.

Das würde mich jetzt mal interessieren da ich dem Fernsehquiz bisher immer recht gab.

Das ist natürlich eine Sache der Definition. Für den Ausdruck "Byte" hat sich keine universelle Definition durchgesetzt. Da wir ja über C und C++ reden, habe ich die Definition von C++ angewandt. Und dort wird eben festgesetzt das ein char immer ein Byte groß ist, und ein Byte aus unterschiedlich vielen Bits bestehen kann, wobei die Anzahl der Bits aber von der Implementierung definiert werden muss.

Also, Char = Byte, mit möglichen Werten im Bereich 0 bis 255.

Ich hatte die Vermutung geäußert das ein char mindestens 8 Bit hat. Mittlerweile muß ich diese Vermutung revidieren. So wie es für mich aussieht, müssen es mindestens nur 7 Bit sein. Meine Vermutung hängt damit zusammen das ein Byte mindestens alle Zeichen des sogenannten "basic execution character set" repräsentieren muss (C++ Standard 1.7), und das sind 100 (2.2). Man braucht also 7 Bit um alle Werte zu repräsentieren. Und ein char muß dieses Werte auch speichern können (3.9.1). Also müsste ein char auch mindestens 7 Bit haben.

Nun sagst du, daß ein Byte auch 47 Bit groß sein kann. Ich gehe mal davon aus, dass die Zahl zu Stande kommt, durch 8x4-1 (von 8 Bit in einem 16-Bit System, 16 Bit pro Char auf einem 32Bit-System und 48 Bit pro Char auf einem 64Bit-System).

Die Zahl 47 hatte ich genommen weil sie so schön krumm ist und ich in einer Newsgroup gelesen hatte, das es tatsächlich ein Architektur gibt bei der 47 Bit chars tatsächlich der Fall sind. Weiterhin etwas dazu gedacht hatte ich mir nicht, tut mir Leid.

Warum ist in fast allen C/C++ Dokumentation noch immer die Rede von Char = 8 Bit, [...]

Das sind dann schlechte Dokumentationen.

Es würde mich wirklich freuen, wenn jemand mir eine URL reichen könnte auf denen dies erklärt ist (konnte selbst trotz ausgiebiger Suche keine finden) oder selbst ein paar Worte dazu verliert.

Zu deinen Überlegungen bezüglich Kompatibilität kann ich nicht viel sagen. Wenn du den C++ Standard nicht zur Hand hast, kannst du aber trotzdem im Draft Standard nachgucken. Die Dinge die ich in diesem Posting genannt habe, sind auch da schon nachvollziehbar drin.
Den Draft Standard findest du z.B. unter:
http://www.csci.csusb.edu/dick/c++std/cd2/index.html
Sogar meine Kapitelangaben stimmen damit überein ! :-)

[dipesh]

Danke für die ausführliche Antwort Locus Vivendi und danke für den sehr interessanten Link!

Das ist natürlich eine Sache der Definition. Für den Ausdruck "Byte" hat sich keine universelle Definition durchgesetzt. Da wir ja über C und C++ reden, habe ich die Definition von C++ angewandt. Und dort wird eben festgesetzt das ein char immer ein Byte groß ist, und ein Byte aus unterschiedlich vielen Bits bestehen kann, wobei die Anzahl der Bits aber von der Implementierung definiert werden muss.

Stimmt. Scheint so ich bin meinem Wissen über PC-kompatible Systeme erlegen. Schließlich ist C/C++ für wesentlich mehr Architekturen gedacht. Um deine Aussage zu untermauern;

http://www.csci.csusb.edu/dick/c++std/cd2/expr.html, Section 5.3.3
sizeof(char), sizeof(signed char) and sizeof(unsigned char) are 1; the result of sizeof applied to any other fundamental type is implementation-defined.

http://www.csci.csusb.edu/dick/c++st...l#intro.memory, Section 1.6
A byte is at least large enough to contain any member of the basic execution character set and is composed of a contiguous sequence of bits, the number of which is implementation-defined.

So wie es für mich aussieht, müssen es mindestens nur 7 Bit sein. Meine Vermutung hängt damit zusammen das ein Byte mindestens alle Zeichen des sogenannten "basic execution character set" repräsentieren muss (C++ Standard 1.7), und das sind 100 (2.2). Man braucht also 7 Bit um alle Werte zu repräsentieren. Und ein char muß dieses Werte auch speichern können (3.9.1). Also müsste ein char auch mindestens 7 Bit haben.

Den Abschnitt http://www.csci.csusb.edu/dick/c++st...ml#lex.charset hab ich mittlerweile auch mehrmals gelesen. Scheint tatsächlich so, daß 128 mögliche Zustände und damit 7 Bit pro Byte ausreichend wären. Sehr interessant.

Das sind dann schlechte Dokumentationen.

Leider. Kein Wunder, daß man in all den Jahren Studium darüber nichts erfährt :-(

Wenn du den C++ Standard nicht zur Hand hast

Der drafts-Link ist bereits ein dicker Brocken und sollte mich die nächsten Tage ausreichend genug beschäftigen. Da ich jemand bin der Informationen dieser Art gerne in sich aufnimmt, wäre es schön, wenn du in deinen Bookmarks noch mal nachgucken könntest, ob sich da noch mehr solcher existenziell wichtigen Links finden. Auch hier bedanke ich mich schon einmal im voraus und - falls noch nicht bekannt - kann http://www.dwheeler.com/secure-progr...WTO/index.html weiterempfehlen. Auch eine lesenswerte Dokumentation.

[locus vivendi]

Der drafts-Link ist bereits ein dicker Brocken und sollte mich die nächsten Tage ausreichend genug beschäftigen.

Freut mich das du dich dafür interessierst. Bitte bedenke natürlich immer das der "Draft" nicht Normativ ist!

Da ich jemand bin der Informationen dieser Art gerne in sich aufnimmt, wäre es schön, wenn du in deinen Bookmarks noch mal nachgucken könntest, ob sich da noch mehr solcher existenziell wichtigen Links finden.

Hm, soviele Links parat habe ich jetzt nicht. Auf www.cetus-links.org findet man eine ganze Menge, falls du das noch nicht kennst. Leider sind viele Links dort nicht mehr aktuell. Nicht unbedingt "existenziell wichtig", aber dennoch empfehlenswert finde ich z.B. Bjarne Stroustrups FAQ (zu finden bei cetus), die C++ FAQ Lite (www.parashift.com) und www.semantics.org (Dort speziell "Once, Weakly").

Auch hier bedanke ich mich schon einmal im voraus und - falls noch nicht bekannt - kann http://www.dwheeler.com/secure-prog...OWTO/index.html weiterempfehlen.

Kenne ich schon, aber trotzdem vielen Dank.