Bestands-I/O in C: Bestanden aanmaken, openen, lezen en schrijven

Bestanden in C

Een bestand is een reeks bytes. C biedt hoog-niveau (gestreamde) en laag-niveau (OS) I/O. Hier focussen we op FILE* streams uit <stdio.h>.

Bestand openen: `fopen()`

FILE *fopen(const char *pad, const char *modus);

Tekstmodi

Modus	Beschrijving
`r`	Lezen (bestand moet bestaan)
`w`	Schrijven (maakt nieuw of leegt bestaand)
`a`	Toevoegen (maakt nieuw of opent bestaand)
`r+`	Lezen + schrijven (bestaand)
`w+`	Lezen + schrijven (leegt/maakt)
`a+`	Lezen + toevoegen

Binaire modi

Voeg b toe: rb, wb, ab, rb+, wb+, ab+. Essentieel op Windows (geen regelvertaling), op Unix identiek.

Bestand sluiten: `fclose()`

int fclose(FILE *fp);

Retourneert 0 bij succes, EOF bij fout. Fluist buffer, vrijgeeft resources. Altijd sluiten!

Schrijven naar bestand

Functie	Doel
`fputc(int c, FILE *fp)`	Één karakter schrijven
`fputs(const char s, FILE fp)`	String schrijven (geen auto newline)
`fprintf(FILE fp, const char fmt, ...)`	Geformatteerd schrijven (zoals printf)

Voorbeeld schrijven

#include <stdio.h>

int main() {
    FILE *fp = fopen("/tmp/test.txt", "w");
    if (!fp) { perror("fopen"); return 1; }

    fprintf(fp, "Regel 1: fprintf\n");
    fputs("Regel 2: fputs\n", fp);
    fputc('A', fp);
    fputc('\n', fp);

    fclose(fp);
    return 0;
}

Lezen uit bestand

Functie	Doel
`fgetc(FILE *fp)`	Één karakter lezen (int, EOF op einde/fout)
`fgets(char buf, int n, FILE fp)`	Regel lezen (max n-1 chars, incl. \n, null-terminated)
`fscanf(FILE fp, const char fmt, ...)`	Geformatteerd lezen (stopt bij whitespace)

Voorbeeld lezen

#include <stdio.h>

int main() {
    FILE *fp = fopen("/tmp/test.txt", "r");
    if (!fp) { perror("fopen"); return 1; }

    char buf[256];

    // fscanf leest tot whitespace
    fscanf(fp, "%255s", buf);
    printf("1 (fscanf): %s\n", buf);  // "Regel"

    // fgets leest rest van regel
    fgets(buf, sizeof(buf), fp);
    printf("2 (fgets): %s", buf);  // " 1: fprintf\n"

    // Volgende regel
    fgets(buf, sizeof(buf), fp);
    printf("3 (fgets): %s", buf);  // "Regel 2: fputs\n"

    fclose(fp);
    return 0;
}

Binaire I/O: `fread()` en `fwrite()`

Voor blokken geheugen (arrays, structs).

size_t fread(void *ptr, size_t grootte, size_t aantal, FILE *fp);
size_t fwrite(const void *ptr, size_t grootte, size_t aantal, FILE *fp);

Voorbeeld: struct array schrijven/lezen

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

struct Persoon {
    char naam[32];
    int leeftijd;
};

int main() {
    struct Persoon mensen[2] = {
        {"Anna", 28},
        {"Bert", 35}
    };

    FILE *fp = fopen("data.bin", "wb");
    fwrite(mensen, sizeof(struct Persoon), 2, fp);
    fclose(fp);

    // Lezen terug
    struct Persoon ingelezen[2];
    fp = fopen("data.bin", "rb");
    fread(ingelezen, sizeof(struct Persoon), 2, fp);
    fclose(fp);

    for (int i = 0; i < 2; i++) {
        printf("%s, %d jaar\n", ingelezen[i].naam, ingelezen[i].leeftijd);
    }
    return 0;
}