Работа с файлами в 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, "Не удалось открыть файл на запись.\n");
        return 1;
    }

    fprintf(fp, "Привет, файл!\n");
    fprintf(fp, "Записано программой на C.\n");

    fclose(fp);
    printf("Записан 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, "не удаётся открыть %s на запись\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, "не удаётся открыть %s на чтение\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("среднее: %.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, "первая строка\n");
    fprintf(out, "вторая строка\n");
    fprintf(out, "третья строка\n");
    fclose(out);

    FILE *in = fopen(path, "r");
    if (in == NULL) {
        fprintf(stderr, "не удаётся открыть %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 символов)\n", lineno, line, strlen(line));
    }

    fclose(in);
    return 0;
}

Почему fgets — правильный выбор по умолчанию:

• Он принимает размер буфера, поэтому не может его переполнить. Передавайте sizeof line — и вызов останется корректным, даже если вы измените размер массива.
• Он возвращает NULL в конце файла или при ошибке, что даёт чистое условие цикла.
• Он сохраняет перевод строки, когда строка поместилась в буфер. Это полезно: отсутствие '\n' в полученном означает, что строка оказалась длиннее буфера и остаток ещё ждёт. strcspn(line, "\n") находит индекс перевода строки (или длину строки, если его нет), поэтому запись '\0' по этому индексу обрезает её в обоих случаях.

Чтобы отличить настоящий конец файла от ошибки, спросите после цикла:

if (ferror(in)) {
    fprintf(stderr, "ошибка чтения\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, строк: %d\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, "не удалось открыть: %s\n", strerror(errno));
        perror("perror сообщает");
        return 1;
    }
    fclose(fp);
    return 0;
}

errno хранит код, описывающий последнюю неудачу, а strerror превращает его во фразу; perror выводит ваше сообщение вместе с этой фразой за один вызов. Им нужны <errno.h> и <string.h> соответственно.

fclose тоже может завершиться неудачей — он сбрасывает буферизованные данные, а запись может не поместиться на диск, — поэтому для чего-то важного проверяйте и его:

if (fclose(fp) != 0) {
    fprintf(stderr, "не удалось сбросить буфер и закрыть файл\n");
}

Бинарный режим в одном абзаце

Текстовый режим может преобразовывать окончания строк (в Windows \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("прочитано записей: %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) записывает 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") ищет в рабочем каталоге, а не рядом с исполняемым файлом. Если файл «пропал», обычно причина именно в этом.