Aus Datei lesen und im Char-Array mit Lesefunktion speichern

Question

Ich möchte mit der Lesefunktion aus einer Datei lesen und die enthaltenen Dateien in einem Array von Zeichen speichern. Ich weiß, dass das Problem ist, dass ich Zeichen speichern und ich möchte eine Zeichenfolge drucken. Wie kann ich meine Zeichenfolge erhalten?

#include <stdio.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <stdlib.h> 
#define MAX 1024 



int main(int argc, char **argv) 
{ 
    int f1; 
    char *buf; 
    char *rez = (char*)malloc(sizeof(char)* MAX); 
    buf = (char*)malloc(sizeof(char)* MAX); 
    if((f1=open("fis4.txt", O_RDONLY)) < 0) 
    { 
     printf("Error\n"); 
     exit(1); 
    } 
    int i = 0; 
    while((read(f1, &buf,1))>0) 
    { 
     rez[i]=buf[i]; 
     i++; 
    } 

    printf("%s", rez); 

    close(f1); 

return 0; 

} 

Answer 1

Es gibt einige Probleme in Ihrem Code. Zuerst müssen Sie in der while-Schleife testen, ob i größer als MAX ist. In diesem Fall müssen Sie die Schleife beenden, um einen Pufferüberlauf zu vermeiden. Wie jetzt, wenn die Datei länger als 1024 Zeichen ist, stürzt sie ab, weil Sie versuchen, außerhalb des Arrays zu schreiben. Um dies zu vermeiden, fügen Sie diesen Code auf die while-Schleife (nach i++):

if(i + 1 >= MAX){ 
    break; 
} 

Der break; Befehl wird die while-Schleife beenden.

Zweitens müssen Strings mit einem Nullzeichen enden. Also muss man auf jede Saite nach der while-Schleife wie folgt ein Null-Zeichen hinzufügen:

rez[i] = '\0'; 
buf[i] = '\0'; 

Beachten Sie, dass bei der Prüfung, ob i größer als MAX ist, haben wir if(i + 1 >= MAX) statt if(i >= MAX) Raum für die Null-Zeichen zu verlassen.

Drittens, niemals malloc ohne free verwenden, sonst wird ein Speicherverlust verursacht. Sie haben wie diese rez und buf am Ende des Programms zu befreien:

free(rez); 
free(buf); 

Eine Alternative dazu, die in Ihrem Fall funktioniert aber nicht immer rez und buf als einfache Arrays zu erklären wären ohne malloc mit:

Dies funktioniert seit MAX ist ein Makro und keine Variable.

Viertens, lassen Sie niemals einen Zeiger nicht initialisiert. Stattdessen initialisieren es NULL:

char *buf = NULL; 

jedoch in Ihrem Fall wäre es besser, es direkt an malloc zu initialisieren:

char *buf = (char*)malloc(sizeof(char) * MAX); 

Beachten Sie, dass in C, ist es nicht erforderlich, noch empfohlen, Wirf das Ergebnis von malloc (obwohl es in C++ benötigt wird). Der folgende Code wäre daher besser sein:

char *buf = malloc(sizeof(char) * MAX); 

Für weitere Informationen können Sie this lesen.

Fünftens, wie im Kommentar vorgeschlagen, müssen Sie überprüfen, ob die Speicherzuweisung von malloc fehlgeschlagen ist, in diesem Fall müssen Sie das Programm beenden, um undefiniertes Verhalten zu vermeiden. Wenn die Speicherzuordnung fehlgeschlagen ist, lautet der Rückgabewert mallocNULL.Das gibt diesen Code, dass Sie nach malloc platzieren sollte:

if(rez == NULL || buf == NULL){ 
    printf("Memory allocation failed.\n"); 
    exit(8); 
} 

Der Rückgabewert in diesem Fall wäre 8, wenn Sie die standard return values folgen wollen. Natürlich können Sie den gewünschten Wert zurückgeben, wenn Sie dem Standard nicht folgen möchten. Wenn Sie dem Standard folgen möchten, sollte der Rückgabewert auch 2 sein, wenn die Datei nicht gefunden wird (nicht 1 wie in Ihrem Code). Sie können auch die Makros ERROR_FILE_NOT_FOUND (gleich 2) und ERROR_NOT_ENOUGH_MEMORY (gleich 8) verwenden. Diese Makros finden Sie in windows.h (obwohl ich nicht weiß, ob Sie diese Datei haben, seit Sie Linux verwenden).

Eine Version des Codes, der würde dann funktioniert:

#include <stdio.h> 
#include <stdlib.h> 
#define MAX 1024 

int main(int argc, char **argv){ 
    FILE *f1; 
    char *buf = malloc(sizeof(char) * MAX); 
    char *rez = malloc(sizeof(char) * MAX); 
    if((f1=fopen("fis4.txt", "r")) == NULL){ 
     printf("Error\n"); 
     exit(2); 
    } 
    if(rez == NULL || buf == NULL){ 
     printf("Memory allocation failed.\n"); 
     exit(8); 
    } 
    int i = 0; 
    while((buf[i] = fgetc(f1)) != EOF){ 
     rez[i] = buf[i]; 
     i++; 
     if(i + 1 >= MAX){ 
      break; 
     } 
    } 

    rez[i] = '\0'; 
    buf[i] = '\0'; 
    printf("%s", rez); 

    free(rez); 
    free(buf); 

    fclose(f1); 

    return 0; 
}