עבודה עם קבצים ב-C: fopen, fclose וקריאת קובץ שורה אחר שורה

כל מה שתוכנית מחשבת נעלם כשהיא יוצאת, אלא אם היא כותבת אותו. ממשק הקבצים של C נמצא ב-<stdio.h>, אותו קובץ כותרת של printf, והוא דומה בכוונה: קובץ הוא זרם (stream) של בתים, ולפונקציות שעובדות על המסך יש תאומות שמקבלות ארגומנט של זרם.

טיפוס הידית הוא FILE *. אף פעם לא מסתכלים לתוך FILE; זה טיפוס אטום (ראו typedef) ומחזיקים רק מצביע אליו.

שלושת השלבים

כל פעולה על קובץ הולכת לפי אותה צורה: פותחים, משתמשים, סוגרים.

#include <stdio.h>

int main(void) {
    FILE *fp = fopen("greeting.txt", "w");
    if (fp == NULL) {
        fprintf(stderr, "Could not open the file for writing.\n");
        return 1;
    }

    fprintf(fp, "Hello, file!\n");
    fprintf(fp, "Written by a C program.\n");

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

בדיקת ה-NULL אינה פרנויה אופציונלית. fopen נכשלת בכל פעם שהקובץ לא קיים (במצב קריאה), שאין הרשאת כתיבה לתיקייה, שהנתיב שגוי או שלתהליך נגמרו ידיות הקבצים, וכל אחד מהמקרים האלה מחזיר NULL. שימוש בידית NULL הוא segmentation fault.

שליחת השגיאה ל-stderr במקום ל-stdout היא המוסכמה: הוא לא עובר דרך חוצץ, ואפשר להפנות אותו בנפרד מהפלט האמיתי.

המצבים של fopen

הארגומנט השני הוא מחרוזת מצב קצרה. טעות בה היא הטעות ההרסנית ביותר בכל התחום הזה, כי "w" מרוקן בשקט קובץ קיים.

הוסיפו b לכל אחד מאלה ("rb", "wb", "ab+") למצב בינארי; עוד על זה בסוף.

שני כללים שמונעים אובדן נתונים אמיתי:

• השתמשו ב-"r" כשאתם מתכוונים לקרוא. "r+" על שם קובץ עם שגיאת הקלדה נכשל בבטחה; "w+" יוצר קובץ ריק ולא איבדתם כלום חוץ מזמן. "w" על שם הקובץ הנכון כשהתכוונתם ל-"r" הורס את הנתונים.
• השתמשו ב-"a" ליומנים. כל fprintf נוחת בסוף בלי קשר למיקום של הזרם, וזה בדיוק מה שיומן רוצה.

כתיבה וקריאה בתוכנית אחת

העורך שלמטה מריץ סבב מלא: הוא יוצר קובץ, כותב לתוכו רשומות, סוגר אותו, פותח אותו מחדש לקריאה ומדפיס את מה שהוא מוצא.

#include <stdio.h>

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

    /* --- write --- */
    FILE *out = fopen(path, "w");
    if (out == NULL) {
        fprintf(stderr, "cannot open %s for writing\n", path);
        return 1;
    }
    fprintf(out, "Ada %d\n", 92);
    fprintf(out, "Grace %d\n", 105);
    fprintf(out, "Alan %d\n", 87);
    fclose(out);

    /* --- read it back --- */
    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "cannot open %s for reading\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("average: %.1f\n", (double)total / count);
    }
    return 0;
}

fprintf ו-fscanf הן printf ו-scanf עם זרם כארגומנט הראשון; כל מה שנוגע למצייני הפורמט שלהן זהה, כולל הרוחב %31s ששומר על name מגלישה.

תנאי הלולאה הוא == 2, מספר הפריטים שהפורמט מבקש. בדיקה מול EOF במקום זה היא באג קלאסי: שורה פגומה גורמת ל-fscanf להחזיר 0, לא EOF, והלולאה מסתובבת לנצח על קלט שהיא לא יכולה לצרוך.

קריאה שורה אחר שורה עם fgets

fscanf נוחה לנתונים בפורמט נוקשה. עבור קובצי טקסט, קובצי הגדרות, יומנים, CSV, כל דבר שאדם כתב, קראו שורות שלמות. זו הלולאה הקלאסית:

#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, "first line\n");
    fprintf(out, "second line\n");
    fprintf(out, "third line\n");
    fclose(out);

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

    char line[256];
    int  lineno = 0;

    while (fgets(line, sizeof line, in) != NULL) {
        line[strcspn(line, "\n")] = '\0';    /* trim the trailing newline */
        lineno++;
        printf("%3d: [%s] (%zu chars)\n", lineno, line, strlen(line));
    }

    fclose(in);
    return 0;
}

מה שהופך את fgets לברירת המחדל הנכונה:

• היא מקבלת את גודל החוצץ, ולכן לא יכולה לגלוש. העבירו sizeof line והקריאה נשארת נכונה גם אם תשנו את גודל המערך.
• היא מחזירה NULL בסוף הקובץ או בשגיאה, וזה תנאי לולאה נקי.
• היא שומרת את תו השורה החדשה כשהשורה נכנסה בחוצץ. זה שימושי: אם אין '\n' במה שקיבלתם, השורה הייתה ארוכה מהחוצץ ושאר השורה עדיין מחכה. strcspn(line, "\n") מוצאת את האינדקס של תו השורה החדשה (או את אורך המחרוזת אם אין כזה), כך שהשמת '\0' שם חותכת אותו בכל מקרה.

כדי להבחין בין סוף קובץ אמיתי לבין שגיאה, שאלו אחרי הלולאה:

if (ferror(in)) {
    fprintf(stderr, "read error\n");
} else if (feof(in)) {
    /* normal end */
}

אל תכתבו while (!feof(fp)) כתנאי לולאה. feof הופכת לאמת רק אחרי שקריאה כבר נכשלה, כך שהלולאה הזו מעבדת את התוכן האחרון של החוצץ פעם נוספת. בדקו במקום זה את ערך ההחזרה של פונקציית הקריאה, כמו ששתי הלולאות למעלה עושות.

תו אחר תו: fgetc ו-fputc

לעבודה ברמת הבית, ספירת תווים, שינוי של קובץ, העתקה, fgetc ו-fputc מטפלות בתו אחד בכל קריאה.

#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("Hello there, C programmer!\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("%d letters, %d lines\n", letters, lines);

    /* show the result */
    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;
}

פרט אחד שחשוב: c מוצהר כ-int, לא כ-char. fgetc מחזירה int כדי שתוכל להחזיר כל ערך אפשרי של בית וגם את הזקיף הנפרד EOF (שהוא -1). שמירתו ב-char הופכת את ההשוואה מול EOF לשקר תמיד, או לאמת בטעות עבור הבית 0xFF, תלוי אם char הוא עם סימן בפלטפורמה שלכם. זו אחת המלכודות הוותיקות ביותר של C.

בדיקת שגיאות כמו שצריך

קריאה בקוד ייצור נראית כך:

#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, "open failed: %s\n", strerror(errno));
        perror("perror says");
        return 1;
    }
    fclose(fp);
    return 0;
}

errno מחזיק קוד שמתאר את הכישלון האחרון ו-strerror הופכת אותו למשפט; perror מדפיסה את ההודעה שלכם ועוד את המשפט הזה בקריאה אחת. הן צריכות את <errno.h> ואת <string.h> בהתאמה.

גם fclose יכולה להיכשל: היא מרוקנת נתונים מהחוצץ, והכתיבה עלולה לא להיכנס בדיסק, אז בכל דבר חשוב, בדקו אותה:

if (fclose(fp) != 0) {
    fprintf(stderr, "failed to flush and close\n");
}

מצב בינארי בפסקה אחת

מצב טקסט עשוי לתרגם סיומות שורה (ב-Windows, \n הופך ל-\r\n בכתיבה וחוזר בקריאה) ועשוי להתייחס לבתים מסוימים באופן מיוחד. לנתונים שאינם טקסט, תמונה, struct שנשפך כמו שהוא, גוש דחוס, פתחו עם b והשתמשו ב-fread/fwrite, שמעבירות בתים גולמיים:

#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("read %zu records\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) כותבת count פריטים של size בתים ומחזירה כמה מהם היא הצליחה לכתוב; fread היא תמונת המראה שלה. שימו לב שקובץ שנכתב כך קשור למכונה שכתבה אותו: ריפוד של structs, גודל של מספרים שלמים וסדר בתים כולם דולפים לתוך הבתים, כך שזה בסדר לקובץ מטמון או לקובץ זמני ושגוי לפורמט שתוכניות אחרות צריכות לקרוא.

טעויות נפוצות

• לא לבדוק את fopen מול NULL. הקריסה שבאה אחר כך מואשמת בקריאה, לא בפתיחה.
• פתיחה עם "w" כשהתכוונתם ל-"r". הקובץ מרוקן לפני שאתם שמים לב.
• לשכוח fclose. פלט בחוצץ הולך לאיבוד, וכל קובץ שלא נסגר מדליף ידית.
• while (!feof(fp)). מעבד את השורה האחרונה פעמיים. בדקו במקום זה את ערך ההחזרה של פונקציית הקריאה.
• char c = fgetc(fp). שובר את ההשוואה מול EOF. השתמשו ב-int.
• fscanf("%s", buf) בלי רוחב. אותה גלישת חוצץ כמו scanf מהמקלדת.
• נתיבים יחסיים. fopen("data.txt", "r") מחפשת בתיקיית העבודה, לא ליד קובץ ההרצה. אם קובץ "נעלם", זו בדרך כלל הסיבה.