C-Dateien-E/A: Erstellen, Öffnen, Lesen, Schreiben und Schließen einer Datei

C Dateiverwaltung

Eine Datei kann zur Speicherung großer Mengen persistenter Daten verwendet werden. Wie viele andere Programmiersprachen bietet auch C folgende Dateiverwaltungsfunktionen. Funktionen,

1. Erstellung einer Datei
2. Öffnen einer Datei
3. Eine Datei lesen
4. In eine Datei schreiben
5. Schließen einer Datei

Nachfolgend sind die wichtigsten Dateiverwaltungsfunktionen aufgeführt, die in C:

So erstellen Sie eine Datei

Wann immer Sie mit einer Datei arbeiten möchten, besteht der erste Schritt darin, eine Datei zu erstellen. Eine Datei ist nichts anderes als Speicherplatz in einem Speicher, in dem Daten gespeichert werden.

Um eine Datei in einem C-Programm zu erstellen, wird folgende Syntax verwendet:

FILE *fp;
fp = fopen ("file_name", "mode");

In der obigen Syntax ist die Datei eine Datenstruktur, die in der Standardbibliothek definiert ist.

fopen ist eine Standardfunktion, die zum Öffnen einer Datei verwendet wird.

• Wenn die Datei nicht auf dem System vorhanden ist, wird sie erstellt und dann geöffnet.
• Wenn eine Datei bereits auf dem System vorhanden ist, wird sie direkt mit dieser Funktion geöffnet.

fp ist eine Datei Zeiger die auf die Typdatei verweist.

Wenn Sie eine Datei öffnen oder erstellen, müssen Sie angeben, was Sie mit der Datei tun möchten. Eine Datei in der C-Programmierung kann zum Lesen/Schreiben erstellt oder geöffnet werden. Ein Modus wird verwendet, um anzugeben, ob Sie eine Datei für einen der unten angegebenen Zwecke öffnen möchten. Im Folgenden sind die verschiedenen Arten von Modi in der C-Programmierung aufgeführt, die beim Arbeiten mit einer Datei verwendet werden können.

In der angegebenen Syntax werden der Dateiname und der Modus wie folgt angegeben: Streicher Daher müssen sie immer in doppelte Anführungszeichen gesetzt werden.

Beispielsweise:

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("data.txt", "w");
}

Ausgang:

Die Datei wird in demselben Ordner erstellt, in dem Sie Ihren Code gespeichert haben.

Sie können den Pfad angeben, in dem Sie Ihre Datei erstellen möchten

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("D://data.txt", "w");
}

So schließen Sie eine Datei

Man sollte eine Datei immer schließen, wenn die Vorgänge an der Datei abgeschlossen sind. Das bedeutet, dass der Inhalt und die Links zur Datei beendet werden. Dies verhindert eine versehentliche Beschädigung der Datei.

'C' stellt die Funktion fclose bereit, um Dateischließvorgänge durchzuführen. Die Syntax von fclose lautet wie folgt:

fclose (file_pointer);

Beispielsweise:

FILE *fp;
fp  = fopen ("data.txt", "r");
fclose (fp);

Die Funktion `fclose` erwartet einen Dateizeiger als Argument. Die zugehörige Datei wird anschließend mit `fclose` geschlossen. Sie gibt 0 zurück, wenn das Schließen erfolgreich war, und EOF (Dateiende), falls beim Schließen ein Fehler aufgetreten ist.

Nach dem Schließen der Datei kann derselbe Dateizeiger auch mit anderen Dateien verwendet werden.

Bei der „C“-Programmierung werden Dateien automatisch geschlossen, wenn das Programm beendet wird. Das manuelle Schließen einer Datei durch Schreiben der Funktion „fclose“ ist eine gute Programmierpraxis.

In eine Datei schreiben

Wenn Sie in C in eine Datei schreiben, müssen die Zeilenumbruchzeichen „\n“ explizit hinzugefügt werden.

Die stdio-Bibliothek bietet die notwendigen Funktionen zum Schreiben in eine Datei:

• fputc(char, file_pointer): Es schreibt ein Zeichen in die Datei, auf die file_pointer zeigt.
• fputs(str, file_pointer): Es schreibt eine Zeichenkette in die Datei, auf die file_pointer zeigt.
• fprintf(file_pointer, str, variable_lists): Diese Funktion schreibt einen String in die Datei, auf die file_pointer zeigt. Der String kann optional Formatbezeichner und eine Liste von Variablen (variable_lists) enthalten.

Das folgende Programm zeigt, wie das Schreiben in eine Datei durchgeführt wird:

fputc() Funktion:

#include <stdio.h>
int main() {
        int i;
        FILE * fptr;
        char fn[50];
        char str[] = "Guru99 Rocks\n";
        fptr = fopen("fputc_test.txt", "w"); // "w" defines "writing mode"
        for (i = 0; str[i] != '\n'; i++) {
            /* write to file using fputc() function */
            fputc(str[i], fptr);
        }
        fclose(fptr);
        return 0;
    }

Ausgang:

Das obige Programm schreibt ein einzelnes Zeichen in die Datei fputc_test.txt, bis es das Zeilenumbruchzeichen „\n“ erreicht, welches anzeigt, dass der Satz erfolgreich geschrieben wurde. Dabei wird jedes Zeichen des Arrays in die Datei geschrieben.

1. Im obigen Programm haben wir eine Datei namens fputc_test.txt im Schreibmodus erstellt und geöffnet und deklarieren unseren String, der in die Datei geschrieben wird.
2. Wir führen mithilfe einer For-Schleife einen Schreibvorgang Zeichen für Zeichen durch und fügen jedes Zeichen in unsere Datei ein, bis das Zeichen „\n“ gefunden wird. Anschließend wird die Datei mithilfe der Funktion „fclose“ geschlossen.

fputs() Funktion:

#include <stdio.h>
int main() {
        FILE * fp;
        fp = fopen("fputs_test.txt", "w+");
        fputs("This is Guru99 Tutorial on fputs,", fp);
        fputs("We don't need to use for loop\n", fp);
        fputs("Easier than fputc function\n", fp);
        fclose(fp);
        return (0);
    }

Ausgang:

1. Im obigen Programm haben wir eine Datei namens fputs_test.txt erstellt und im Schreibmodus geöffnet.
2. Nachdem wir mit der Funktion fputs() einen Schreibvorgang durchgeführt haben, indem wir drei verschiedene Zeichenketten geschrieben haben
3. Anschließend wird die Datei mit der Funktion fclose geschlossen.

fprintf()Funktion:

#include <stdio.h>
    int main() {
        FILE *fptr;
        fptr = fopen("fprintf_test.txt", "w"); // "w" defines "writing mode"
        /* write to file */
        fprintf(fptr, "Learning C with Guru99\n");
        fclose(fptr);
        return 0;
    }

Ausgang:

1. Im obigen Programm haben wir eine Datei namens fprintf_test.txt erstellt und im Schreibmodus geöffnet.
2. Nachdem ein Schreibvorgang mit der Funktion fprintf() durch Schreiben einer Zeichenfolge ausgeführt wurde, wird die Datei mit der Funktion fclose geschlossen.

Daten aus einer Datei lesen

Es gibt drei verschiedene Funktionen zum Lesen von Daten aus einer Datei

• fgetc(Dateizeiger): Diese Funktion gibt das nächste Zeichen der Datei zurück, auf die der Dateizeiger zeigt. Sobald das Dateiende erreicht ist, wird EOF zurückgegeben.
• fgets(buffer, n, file_pointer): Es liest n-1 Zeichen aus der Datei und speichert die Zeichenkette in einem Puffer, an den das NULL-Zeichen '\0' als letztes Zeichen angehängt wird.
• fscanf(Dateizeiger, Konvertierungsspezifizierer, Variablenadressen): Diese Funktion dient zum Parsen und Analysieren von Daten. Sie liest Zeichen aus der Datei und weist die Eingabe mithilfe von Konvertierungsspezifizierern einer Liste von Variablenzeigern (Variablenadressen) zu. Beachten Sie, dass fscanf, wie auch scanf, das Einlesen einer Zeichenkette beendet, sobald ein Leerzeichen oder ein Zeilenumbruch auftritt.

Das folgende Programm demonstriert das Lesen aus der Datei fputs_test.txt unter Verwendung der Funktionen fgets(), fscanf() und fgetc():

#include <stdio.h>
int main() {
        FILE * file_pointer;
        char buffer[30], c;

        file_pointer = fopen("fprintf_test.txt", "r");
        printf("----read a line----\n");
        fgets(buffer, 50, file_pointer);
        printf("%s\n", buffer);

        printf("----read and parse data----\n");
        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        char str1[10], str2[2], str3[20], str4[2];
        fscanf(file_pointer, "%s %s %s %s", str1, str2, str3, str4);
        printf("Read String1 |%s|\n", str1);
        printf("Read String2 |%s|\n", str2);
        printf("Read String3 |%s|\n", str3);
        printf("Read String4 |%s|\n", str4);

        printf("----read the entire file----\n");

        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        while ((c = getc(file_pointer)) != EOF) printf("%c", c);

        fclose(file_pointer);
        return 0;
    }

Ergebnis:

----read a line----
Learning C with Guru99

----read and parse data----
Read String1 |Learning|
Read String2 |C|
Read String3 |with|
Read String4 |Guru99|
----read the entire file----
Learning C with Guru99

1. Im obigen Programm haben wir die Datei „fprintf_test.txt“ geöffnet, die zuvor mit der Funktion fprintf() erstellt wurde und den Inhalt „Learning C with“ enthält. GuruDie Zeichenkette „99“ wird mithilfe der Funktion fgets() zeilenweise gelesen, wobei die Puffergröße ausreichend sein muss, um die gesamte Zeile zu verarbeiten.
2. Wir öffnen die Datei erneut, um den Dateizeiger auf den Dateianfang zurückzusetzen. Wir erstellen verschiedene String-Variablen, um jedes Wort einzeln zu verarbeiten. Anschließend geben wir die Variablen aus, um ihren Inhalt anzuzeigen. Die Funktion `fscanf()` wird hauptsächlich verwendet, um …tract und Daten aus einer Datei parsen.
3. Öffnen Sie die Datei erneut, um die Zeigerdatei so zurückzusetzen, dass sie auf den Anfang der Datei zeigt. Lesen Sie Daten und drucken Sie sie Zeichen für Zeichen aus der Datei mit der Funktion getc() aus, bis die EOF-Anweisung auftritt
4. Nachdem wir mit verschiedenen Varianten einen Lesevorgang der Datei durchgeführt haben, haben wir die Datei erneut mit der Funktion fclose geschlossen.

Interaktives Lesen und Schreiben von Dateien mit getc und putc

Dies sind die einfachsten Dateioperationen. Getc steht für „Get Character“ und putc für „Put Character“. Diese beiden Funktionen werden verwendet, um jeweils nur ein einzelnes Zeichen zu verarbeiten.

Das folgende Programm demonstriert die Dateiverwaltungsfunktionen in der C-Programmierung:

#include <stdio.h>
int main() {
        FILE * fp;
        char c;
        printf("File Handling\n");
        //open a file
        fp = fopen("demo.txt", "w");
        //writing operation
        while ((c = getchar()) != EOF) {
            putc(c, fp);
        }
        //close file
        fclose(fp);
        printf("Data Entered:\n");
        //reading
        fp = fopen("demo.txt", "r");
        while ((c = getc(fp)) != EOF) {
            printf("%c", c);
        }
        fclose(fp);
        return 0;
    }

Ausgang:

1. Im obigen Programm haben wir eine Datei namens Demo erstellt und im Schreibmodus geöffnet.
2. Nachdem ein Schreibvorgang ausgeführt wurde, wird die Datei mit der Funktion fclose geschlossen.
3. Wir haben erneut eine Datei geöffnet, die nun Daten im Lesemodus enthält. Eine While-Schleife wird ausgeführt, bis das Ende der Datei gefunden ist. Sobald das Ende der Datei gefunden ist, wird der Vorgang beendet und die Daten werden mithilfe der Funktion printf angezeigt.
4. Nach der Durchführung eines Lesevorgangs wird die Datei mit der Funktion fclose wieder geschlossen.

Häufig gestellte Fragen