C Bestands I/O Beheersen: Bestanden Maken, Openen, Lezen, Schrijven en Sluiten met Vertrouwen

C Bestandsbeheer Overzicht

In C biedt de standaardbibliotheek stdio.h een uitgebreide suite van functies voor het werken met persistente data op schijf. Door deze tools te beheersen kun je betrouwbaar bestanden aanmaken, lezen, schrijven en sluiten, terwijl je data-integriteit en programmatische stabiliteit waarborgt.

Belangrijke Bestandsverwerkingsfuncties

Bestandsmodi Uitgelegd

Een Bestand Aanmaken

Om een bestand aan te maken of te openen, declareer je eerst een bestandspointer, roep dan fopen() aan met de gewenste bestandsnaam en modus:

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

Als het bestand niet bestaat, creëert fopen() het. Als het al bestaat, bepaalt de modus of de inhoud bewaard of overschreven wordt.

Je kunt ook een absoluut pad opgeven:

fp = fopen("D:/data.txt", "w");

Afbeeldingen die de aanmaakstap illustreren:

Een Bestand Sluiten

Nadat je alle bestandsoperaties voltooid hebt, roep je altijd fclose() aan om de bestanddescriptor vrij te geven en buffers te flushen:

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

De functie retourneert 0 bij succes en EOF bij fout. Hoewel het besturingssysteem automatisch bestanden sluit wanneer een programma eindigt, wordt expliciete sluiting als best practice beschouwd.

Naar een Bestand Schrijven

Bij het schrijven, onthoud om newline-karakters (\n) expliciet toe te voegen waar nodig. Hieronder de meest voorkomende schrijffuncties:

• fputc(char, FILE*) – Schrijf een enkel karakter.
• fputs(const char*, FILE*) – Schrijf een null-getermineerde string.
• fprintf(FILE*, const char*, …) – Schrijf geformatteerde output.

Voorbeeld: fputc()

#include <stdio.h>
int main() {
    int i;
    FILE *fptr;
    const char *str = "Guru99 Rocks\n";
    fptr = fopen("fputc_test.txt", "w");
    for (i = 0; str[i] != '\n'; i++) {
        fputc(str[i], fptr);
    }
    fclose(fptr);
    return 0;
}

Uitvoerbestand fputc_test.txt bevat de tekst:

Voorbeeld: fputs()

#include <stdio.h>
int main() {
    FILE *fp = fopen("fputs_test.txt", "w+");
    fputs("Dit is Guru99 Tutorial over fputs,", fp);
    fputs("We hoeven geen for-lus te gebruiken\n", fp);
    fputs("Makkelijker dan fputc-functie\n", fp);
    fclose(fp);
    return 0;
}

Resulterend bestand fputs_test.txt:

Voorbeeld: fprintf()

#include <stdio.h>
int main() {
    FILE *fptr = fopen("fprintf_test.txt", "w");
    fprintf(fptr, "C leren met Guru99\n");
    fclose(fptr);
    return 0;
}

Resulterend bestand fprintf_test.txt:

Uit een Bestand Lezen

Drie primaire functies lezen data:

• fgetc(FILE*) – Retourneert het volgende karakter.
• fgets(char*, int, FILE*) – Leest tot n-1 karakters in een buffer.
• fscanf(FILE*, const char*, …) – Parseert geformatteerde invoer.

Hieronder een complete demonstratie die fprintf_test.txt leest met alle drie methoden:

#include <stdio.h>
int main() {
    FILE *fp;
    char buffer[50], c;
    fp = fopen("fprintf_test.txt", "r");
    printf("----lees een regel----\n");
    fgets(buffer, 50, fp);
    printf("%s\n", buffer);
    fclose(fp);
    fp = fopen("fprintf_test.txt", "r");
    printf("----lees en parseer data----\n");
    char str1[10], str2[2], str3[20], str4[2];
    fscanf(fp, "%s %s %s %s", str1, str2, str3, str4);
    printf("Gelezen String1 |%s|\n", str1);
    printf("Gelezen String2 |%s|\n", str2);
    printf("Gelezen String3 |%s|\n", str3);
    printf("Gelezen String4 |%s|\n", str4);
    fclose(fp);
    fp = fopen("fprintf_test.txt", "r");
    printf("----lees het hele bestand----\n");
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }
    fclose(fp);
    return 0;
}

Programma-output:

----lees een regel----
C leren met Guru99
----lees en parseer data----
Gelezen String1 |C|
Gelezen String2 |leren|
Gelezen String3 |met|
Gelezen String4 |Guru99|
----lees het hele bestand----
C leren met Guru99

Interactieve Karakter-voor-Karakter I/O met getc en putc

Dit minimaal voorbeeld demonstreert gebruikersinvoer lezen, naar een bestand schrijven, en teruglezen:

#include <stdio.h>
int main() {
    FILE *fp;
    int c;
    printf("Bestandsverwerking\n");
    fp = fopen("demo.txt", "w");
    while ((c = getchar()) != EOF) {
        putc(c, fp);
    }
    fclose(fp);
    printf("Ingevoerde Data:\n");
    fp = fopen("demo.txt", "r");
    while ((c = fgetc(fp)) != EOF) {
        putchar(c);
    }
    fclose(fp);
    return 0;
}

Voorbeeldrun:

Kernpunten

• Een bestand is een persistente opslagruimte op schijf.
• De C-standaardbibliotheek biedt fopen, fclose, fprintf, fscanf en gerelateerde functies voor betrouwbare bestandsmanipulatie.
• Open altijd een bestand in de juiste modus om lezen, schrijven of toevoegen te controleren.
• Sluit bestanden expliciet om buffers te flushen en systeembronnen vrij te geven.
• Gebruik fgetc en putc voor eenvoudige karakterstromen, en fgets / fscanf voor regel- of geformatteerde invoer.
• Bij schrijven, onthoud strings te beëindigen met \n als je regelafbreking wilt.
• Correcte foutafhandeling (controleren op NULL pointers en retourwaarden) is essentieel voor robuuste applicaties.