Obsługa plików w C: fopen, fclose i czytanie pliku linia po linii

Wszystko, co program obliczy, znika, gdy się kończy, chyba że to zapisze. Interfejs plików w C mieszka w <stdio.h>, tym samym nagłówku co printf, i celowo jest do niego podobny: plik to strumień bajtów, a funkcje działające na ekranie mają bliźniaczki, które przyjmują strumień jako argument.

Typ uchwytu to FILE *. Nigdy nie zaglądasz do wnętrza FILE; to typ nieprzezroczysty (zobacz typedef) i zawsze trzymasz tylko wskaźnik do niego.

Trzy kroki

Każda operacja na pliku ma ten sam kształt: otwórz, użyj, zamknij.

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("greeting.txt", "w");
    if (fp == NULL) {
        fprintf(stderr, "Nie udalo sie otworzyc pliku do zapisu.\n");
        return 1;
    }

    fprintf(fp, "Czesc, pliku!\n");
    fprintf(fp, "Zapisane przez program w C.\n");

    fclose(fp);
    printf("Zapisano greeting.txt\n");
    return 0;
}

Sprawdzenie NULL to nie opcjonalna paranoja. fopen zawodzi, gdy plik nie istnieje (w trybie odczytu), katalog nie jest zapisywalny, ścieżka jest błędna albo procesowi skończyły się uchwyty plików, a każdy z tych przypadków zwraca NULL. Użycie uchwytu NULL to segmentation fault.

Wysyłanie błędu na stderr zamiast na stdout to konwencja: ten strumień nie jest buforowany i można go przekierować niezależnie od właściwego wyjścia.

Tryby fopen

Drugi argument to krótki string z trybem. Pomyłka w nim to najbardziej destrukcyjny błąd w całym tym obszarze, bo "w" po cichu opróżnia istniejący plik.

Dopisz b do dowolnego z nich ("rb", "wb", "ab+"), żeby uzyskać tryb binarny; więcej o nim na końcu.

Dwie zasady, które chronią przed prawdziwą utratą danych:

• Używaj "r", gdy chcesz czytać. "r+" z literówką w nazwie pliku bezpiecznie zawodzi; "w+" tworzy pusty plik i tracisz tylko czas. "w" z poprawną nazwą pliku, gdy chodziło ci o "r", niszczy dane.
• Używaj "a" do logów. Każde fprintf trafia na koniec, niezależnie od bieżącej pozycji w strumieniu, a właśnie tego chce log.

Zapis i odczyt w jednym programie

Edytor poniżej wykonuje pełną rundę: tworzy plik, zapisuje do niego rekordy, zamyka go, otwiera ponownie do odczytu i wypisuje, co znalazł.

#include <stdio.h>

int main(void) {
    const char *path = "scores.txt";

    /* --- zapis --- */
    FILE *out = fopen(path, "w");
    if (out == NULL) {
        fprintf(stderr, "nie mozna otworzyc %s do zapisu\n", path);
        return 1;
    }
    fprintf(out, "Ada %d\n", 92);
    fprintf(out, "Grace %d\n", 105);
    fprintf(out, "Alan %d\n", 87);
    fclose(out);

    /* --- odczyt z powrotem --- */
    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "nie mozna otworzyc %s do odczytu\n", path);
        return 1;
    }

    char name[32];
    int  score;
    int  total = 0, count = 0;

    while (fscanf(in, "%31s %d", name, &score) == 2) {
        printf("%-8s %3d\n", name, score);
        total += score;
        count++;
    }
    fclose(in);

    if (count > 0) {
        printf("srednia: %.1f\n", (double)total / count);
    }
    return 0;
}

fprintf i fscanf to printf i scanf ze strumieniem jako pierwszym argumentem; wszystko, co dotyczy ich specyfikatorów formatu, jest identyczne, łącznie z szerokością %31s, która chroni name przed przepełnieniem.

Warunek pętli to == 2, czyli liczba elementów, o które prosi format. Sprawdzanie zamiast tego EOF to klasyczny błąd: niepoprawnie sformatowana linia sprawia, że fscanf zwraca 0, a nie EOF, i pętla kręci się w nieskończoność na wejściu, którego nie potrafi zużyć.

Czytanie linia po linii przez fgets

fscanf jest wygodny dla danych o sztywnym formacie. Pliki tekstowe (konfigurację, logi, CSV, wszystko, co napisał człowiek) czytaj całymi liniami. Oto kanoniczna pętla:

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

int main(void) {
    const char *path = "notes.txt";

    FILE *out = fopen(path, "w");
    if (out == NULL) { return 1; }
    fprintf(out, "pierwsza linia\n");
    fprintf(out, "druga linia\n");
    fprintf(out, "trzecia linia\n");
    fclose(out);

    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "nie mozna otworzyc %s\n", path);
        return 1;
    }

    char line[256];
    int  lineno = 0;

    while (fgets(line, sizeof line, in) != NULL) {
        line[strcspn(line, "\n")] = '\0';    /* obcięcie końcowego znaku nowej linii */
        lineno++;
        printf("%3d: [%s] (znakow: %zu)\n", lineno, line, strlen(line));
    }

    fclose(in);
    return 0;
}

Co sprawia, że fgets jest właściwym domyślnym wyborem:

• Przyjmuje rozmiar bufora, więc nie może go przepełnić. Przekaż sizeof line, a wywołanie pozostanie poprawne, gdy zmienisz rozmiar tablicy.
• Zwraca NULL na końcu pliku albo przy błędzie, co daje czysty warunek pętli.
• Zachowuje znak nowej linii, gdy linia zmieściła się w buforze. To przydatne: brak '\n' w otrzymanym tekście oznacza, że linia była dłuższa niż bufor, a reszta wciąż czeka. strcspn(line, "\n") znajduje indeks znaku nowej linii (albo długość stringa, jeśli go nie ma), więc przypisanie tam '\0' obcina go w obu przypadkach.

Żeby odróżnić prawdziwy koniec pliku od błędu, zapytaj po pętli:

if (ferror(in)) {
    fprintf(stderr, "blad odczytu\n");
} else if (feof(in)) {
    /* normalny koniec */
}

Nie pisz while (!feof(fp)) jako warunku pętli. feof staje się prawdą dopiero po tym, jak odczyt już się nie powiódł, więc taka pętla przetwarza ostatnią zawartość bufora o jeden raz za dużo. Zamiast tego sprawdzaj wartość zwracaną przez funkcję odczytu, tak jak robią to obie pętle powyżej.

Znak po znaku: fgetc i fputc

Do pracy na poziomie bajtów (liczenie znaków, przekształcanie pliku, kopiowanie) służą fgetc i fputc, które obsługują jeden znak na wywołanie.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    const char *src = "mixed.txt";
    const char *dst = "upper.txt";

    FILE *out = fopen(src, "w");
    if (out == NULL) { return 1; }
    fputs("Czesc, programisto C!\n", out);
    fclose(out);

    FILE *in = fopen(src, "r");
    FILE *up = fopen(dst, "w");
    if (in == NULL || up == NULL) {
        if (in) fclose(in);
        if (up) fclose(up);
        return 1;
    }

    int c;
    int letters = 0, lines = 0;

    while ((c = fgetc(in)) != EOF) {
        if (isalpha(c)) letters++;
        if (c == '\n')  lines++;
        fputc(toupper(c), up);
    }

    fclose(in);
    fclose(up);

    printf("liter: %d, linii: %d\n", letters, lines);

    /* pokaż wynik */
    FILE *check = fopen(dst, "r");
    if (check != NULL) {
        char line[128];
        while (fgets(line, sizeof line, check) != NULL) {
            printf("%s", line);
        }
        fclose(check);
    }
    return 0;
}

Jeden ważny szczegół: c jest zadeklarowane jako int, a nie char. fgetc zwraca int, żeby móc zwrócić każdą możliwą wartość bajtu oraz odrębnego wartownika EOF (czyli -1). Zapisanie wyniku w char sprawia, że porównanie z EOF jest albo zawsze fałszywe, albo fałszywie prawdziwe dla bajtu 0xFF, zależnie od tego, czy char na twojej platformie ma znak. To jedna z najstarszych pułapek C.

Porządne sprawdzanie błędów

Odczyt w kodzie produkcyjnym wygląda tak:

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

int main(void) {
    FILE *fp = fopen("does-not-exist.txt", "r");
    if (fp == NULL) {
        fprintf(stderr, "otwarcie nieudane: %s\n", strerror(errno));
        perror("perror mowi");
        return 1;
    }
    fclose(fp);
    return 0;
}

errno przechowuje kod opisujący ostatni błąd, a strerror zamienia go w zdanie; perror wypisuje twój komunikat razem z tym zdaniem w jednym wywołaniu. Wymagają odpowiednio <errno.h> i <string.h>.

fclose też może zawieść (opróżnia zbuforowane dane, a zapis może nie zmieścić się na dysku), więc przy wszystkim, co ważne, sprawdzaj wynik:

if (fclose(fp) != 0) {
    fprintf(stderr, "nie udalo sie oproznic bufora i zamknac pliku\n");
}

Tryb binarny w jednym akapicie

Tryb tekstowy może tłumaczyć znaki końca linii (w Windows \n przy zapisie staje się \r\n, a przy odczycie wraca do \n) i może specjalnie traktować niektóre bajty. Dla danych, które nie są tekstem (obraz, struktura zrzucona bajt w bajt, skompresowany blob), otwieraj plik z b i używaj fread/fwrite, które przenoszą surowe bajty:

#include <stdio.h>

struct Record {
    int    id;
    double value;
};

int main(void) {
    struct Record out[2] = {{1, 3.5}, {2, 7.25}};

    FILE *fp = fopen("records.bin", "wb");
    if (fp == NULL) { return 1; }
    fwrite(out, sizeof out[0], 2, fp);
    fclose(fp);

    struct Record in[2];
    fp = fopen("records.bin", "rb");
    if (fp == NULL) { return 1; }
    size_t got = fread(in, sizeof in[0], 2, fp);
    fclose(fp);

    printf("wczytane rekordy: %zu\n", got);
    for (size_t i = 0; i < got; i++) {
        printf("id=%d value=%.2f\n", in[i].id, in[i].value);
    }
    return 0;
}

fwrite(ptr, size, count, fp) zapisuje count elementów po size bajtów i zwraca, ile udało się zapisać; fread działa lustrzanie. Pamiętaj, że plik zapisany w ten sposób jest związany z maszyną, która go zapisała (wyrównanie struktur, rozmiar liczb całkowitych i kolejność bajtów przenikają do bajtów pliku), więc nadaje się na cache albo plik roboczy, ale nie na format, który mają czytać inne programy.

Częste błędy

• Niesprawdzanie fopen pod kątem NULL. Awarię, która następuje, zrzuca się na odczyt, a nie na otwarcie.
• Otwarcie z "w", gdy chodziło o "r". Plik zostaje opróżniony, zanim to zauważysz.
• Zapomnienie o fclose. Zbuforowane wyjście przepada, a każdy niezamknięty plik to wyciek uchwytu.
• while (!feof(fp)). Przetwarza ostatnią linię dwa razy. Zamiast tego sprawdzaj wywołanie odczytu.
• char c = fgetc(fp). Psuje porównanie z EOF. Używaj int.
• fscanf("%s", buf) bez szerokości. To samo przepełnienie bufora co przy scanf z klawiatury.
• Ścieżki względne. fopen("data.txt", "r") szuka w katalogu roboczym, a nie obok pliku wykonywalnego. Jeśli plik "znika", zwykle właśnie dlatego.