التعامل مع الملفات في لغة C: ‏fopen وfclose وقراءة الملفات سطرًا سطرًا

كل ما يحسبه برنامج يختفي حين يخرج، إلّا إن كتبه. وتعيش واجهة الملفات في C داخل <stdio.h> - الترويسة نفسها التي فيها printf - وهي متشابهة عمدًا: الملف تيّار من البايتات، وللدوال التي تعمل على الشاشة توائم تأخذ وسيط تيّار.

ونوع المقبض هو 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 هو خطأ تجزئة.

وإرسال الخطأ إلى 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";

    /* --- الكتابة --- */
    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);

    /* --- إعادة قراءته --- */
    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';    /* قصّ السطر الجديد الذيلي */
        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)) {
    /* نهاية طبيعية */
}

ولا تكتب 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);

    /* اعرض النتيجة */
    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");
}

الوضع الثنائي في فقرة واحدة

قد يترجم الوضع النصّي نهايات الأسطر (فعلى ويندوز تصير \n هي \r\n عند الكتابة والعكس عند القراءة) وقد يعامل بايتات معيّنة معاملة خاصة. وللبيانات التي ليست نصًا - صورة، أو بنية مفرَّغة حرفيًا، أو كتلة مضغوطة - افتح بـ 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 تقابلها. وانتبه إلى أن ملفًا مكتوبًا بهذه الطريقة مرتبط بالجهاز الذي كتبه - فحشو البنى وحجم الأعداد الصحيحة وترتيب البايتات كلها تتسرّب إلى البايتات - فهو مناسب لذاكرة مؤقّتة أو ملف خردة وخاطئ لصيغة يجب أن تقرأها برامج أخرى.

أخطاء شائعة

• عدم فحص fopen بحثًا عن NULL. فالانهيار التالي يُلقى باللوم فيه على القراءة، لا على الفتح.
• الفتح بـ "w" حين كنت تقصد "r". فيُفرَّغ الملف قبل أن تلاحظ.
• نسيان fclose. فيضيع الخرج المخزَّن مؤقّتًا، ويسرّب كل ملف غير مغلق مقبضًا.
• while (!feof(fp)). تعالج السطر الأخير مرتين. افحص استدعاء القراءة بدلًا من ذلك.
• char c = fgetc(fp). تكسر المقارنة مع EOF. استخدم int.
• fscanf("%s", buf) بلا عرض. هو فيضان المخزن نفسه الذي في scanf على لوحة المفاتيح.
• المسارات النسبية. fopen("data.txt", "r") تبحث في دليل العمل، لا بجوار الملف التنفيذي. وإن "اختفى" ملف، فذلك هو السبب عادةً.