C Файловый ввод-вывод
В предыдущей главе мы объяснили, как язык C работает со стандартными устройствами ввода и вывода. В этой главе будет рассказано, как программисты C создают, открывают и закрывают текстовые или бинарные файлы.
Файл, будь то текстовый или бинарный, представляет собой последовательность байтов. Язык C предоставляет не только функции верхнего уровня, но и низкоуровневые (ОС) вызовы для работы с файлами на устройствах хранения. В этой главе будут объяснены важные вызовы для управления файлами.
Открытие файла
Вы можете использоватьfopen( )— функцию, используемую для создания нового файла или открытия существующего файла. Этот вызов инициализирует типFILE, то есть объект типаFILEкоторый содержит всю необходимую информацию для управления потоком. Ниже приведён прототип этого вызова функции:
FILE *fopen( const char *filename, const char *mode );
Здесьfilename— это строка, используемая для задания имени файла; режим доступаmodeЗначение может быть одним из следующих значений:
| Mode | Описание |
|---|---|
| r | Открывает существующий текстовый файл для чтения. |
| w | Открывает текстовый файл для записи. Если файл не существует, создаётся новый файл. Здесь ваша программа будет записывать содержимое с начала файла. Если файл существует, его содержимое очищается (т. е. длина файла усекается до 0). |
| a | Открывает текстовый файл для записи в режиме добавления. Если файл не существует, создаётся новый файл. Здесь ваша программа будет добавлять содержимое к существующему содержимому файла. |
| r+ | Открывает текстовый файл для чтения и записи одновременно. |
| w+ | Открывает текстовый файл для чтения и записи. Если файл уже существует, он будет усечён до нулевой длины; если файл не существует, будет создан новый файл. |
| a+ | Открывает текстовый файл для чтения и записи. Если файл не существует, создаётся новый файл. Чтение начинается с начала файла, а запись возможна только в режиме добавления. |
Если вы работаете с бинарными файлами, используйте следующие режимы доступа вместо указанных выше режимов доступа:
"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"
Закрытие файла
Чтобы закрыть файл, используйте функцию fclose( ). Прототип функции выглядит следующим образом:
int fclose( FILE *fp );
Если файл успешно закрыт,fclose( )Функция возвращает ноль; если при закрытии файла возникает ошибка, функция возвращаетEOFEOF. Эта функция фактически сбрасывает данные в буфере, закрывает файл и освобождает всю память, использованную для файла. EOF определён в заголовочном файлеstdio.hэта константа в.
Стандартная библиотека C предоставляет различные функции для чтения и записи файлов посимвольно или в виде строк фиксированной длины.
Запись в файл
Ниже приведена простейшая функция для записи символа в поток:
int fputc( int c, FILE *fp );
Функцияfputc()записывает значение символа параметра c в выходной поток, на который указывает fp. В случае успеха она возвращает записанный символ; если возникает ошибка, она возвращаетEOFДля записи строки, завершающейся нулевым символом, в поток можно использовать следующую функцию:
int fputs( const char *s, FILE *fp );
Функцияfputs()строкуsзаписывает в выходной поток, на который указывает fp. В случае успеха она возвращает неотрицательное значение; если возникает ошибка, она возвращаетEOFТакже можно использоватьint fprintf(FILE *fp,const char *format, ...)Функция записывает строку в файл. Попробуйте следующий пример:
Примечание:Пожалуйста, убедитесь, что у вас есть доступныйtmpкаталог. Если каталог не существует, вам нужно сначала создать его на компьютере.
/tmpОбычно это временный каталог в Linux-системах. Если вы работаете в Windows, вам нужно изменить его на существующий каталог в вашей локальной среде, например: C:\tmp、D:\tmpи т. д.
Пример
Когда приведённый выше код скомпилирован и выполнен, он создаёт новый файл в каталоге /tmptest.txtи использует две разные функции для записи двух строк. Далее давайте прочитаем этот файл.
Чтение из файла
Ниже приведена простейшая функция для чтения одного символа из файла:
int fgetc( FILE * fp );
fgetc()Функция читает символ из входного файла, на который указывает fp. Возвращаемое значение — прочитанный символ; если возникает ошибка, она возвращаетEOFСледующая функция позволяет читать строку из потока:
char *fgets( char *buf, int n, FILE *fp );
Функцияfgets()Она читает n - 1 символов из входного потока, на который указывает fp. Она копирует прочитанную строку в буферbuf, и добавляетнулевойсимвол для завершения строки.
Если эта функция встречает символ новой строки '\n' или конец файла EOF до чтения последнего символа, она возвращает только прочитанные символы, включая символ новой строки. Вы также можете использоватьint fscanf(FILE *fp, const char *format, ...)функцию для чтения строк из файла, но она прекращает чтение, когда встречает первый пробел или символ новой строки.
Пример
Когда приведённый выше код скомпилирован и выполнен, он читает файл, созданный в предыдущем разделе, и выдаёт следующие результаты:
1: This 2: is testing for fprintf... 3: This is testing for fputs...
Сначала,fscanf()метод прочитал толькоэто, потому что после этого встретился пробел. Затем вызовитеfgets()чтобы прочитать оставшуюся часть до конца строки. Наконец, вызовитеfgets()Полностью читает вторую строку.
Функции двоичного ввода-вывода
Следующие две функции используются для двоичного ввода и вывода:
size_t fread(void *ptr, size_t size, size_t count, FILE *stream); size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);
freadиfwrite— это основные функции стандартной библиотеки C для чтения и записи двоичных блоков файлов. Они напрямую работают с блоками данных в памяти, избегая накладных расходов на преобразование текстового формата, и особенно подходят для пакетного чтения и записи больших файлов и структурированных данных.
Описание параметра
Четыре параметра имеют одинаковое значение в обеих функциях, но направление потока данных противоположно:
| Параметр | Type | Описание | поведение fread | поведение fwrite |
|---|---|---|---|---|
| ptr | void* / const void* | Указатель на буфер памяти | Адрес назначения при чтении (запись в память) | Адрес источника данных (чтение из памяти) |
| size | size_t | Количество байтов на блок данных | Размер блока при чтении | Размер блока при записи |
| count | size_t | Количество блоков данных для чтения или записи | Ожидаемое количество блоков для чтения | Ожидаемое количество блоков для записи |
| stream | FILE* | Указатель на открытый файл | Должен быть открыт с помощью "rb" | Должен быть открыт с помощью "wb" |
Фактическое количество обрабатываемых байтов составляетsize × countвозвращаемое значение — это количество успешно прочитанных или записанных блоков, а не количество байтов. Если возвращаемое значение меньше count, это может быть вызвано концом файла (EOF) или ошибкой чтения/записи, которые нужно проверять отдельно.
Двоичный режим против текстового режима
При использовании fread/fwrite необходимо открывать файл в двоичном режиме; в противном случае может произойти повреждение данных.
Почему необходимо использовать двоичный режим
Текстовый режим в Windows автоматически преобразует символы новой строки\nПреобразуются в\r\n, что разрушит целостность двоичных данных.
В Linux/macOS текстовый и двоичный режимы ведут себя одинаково, но кроссплатформенный код должен явно использовать"b"флаг для обеспечения переносимости.
Пример
FILE *fp_read = fopen("data.bin", "rb"); // Бинарное чтение
FILE *fp_write = fopen("data.bin", "wb"); // Бинарная запись
// Неправильный подход: текстовый режим (данные могут быть повреждены в Windows)
FILE *fp_bad = fopen("data.bin", "r"); // Отсутствует флаг "b"
Сравнение с текстовыми функциями
Выбор функции зависит от типа данных и требуемого сценария:
| Особенности | fread / fwrite | fprintf / fscanf |
|---|---|---|
| Метод обработки данных | Чтение и запись двоичных данных в память как есть | Преобразование на основе формата (число ↔ строка) |
| Применимые сценарии | Структуры, массивы, изображения, аудио и т. д. | Удобочитаемый человеком текст, например файлы конфигурации, логи, отчёты и т. д. |
| Производительность | Быстро, без накладных расходов на преобразование | Медленно, нужно разобрать строку формата |
| Precision | Без потери точности | Числа с плавающей запятой могут терять точность |
| Удобочитаемый | Нет (двоичный формат) | Да (текстовый формат) |
Блок-схема чтения/записи данных
На следующем рисунке показан поток данных между fread и fwrite, а также между файлом и памятью:
Типичные сценарии использования
Чтение и запись данных структуры
Это наиболее распространённый сценарий применения fread/fwrite; можно прочитать или записать всю структуру как единый блок данных за один раз.
Пример
#include <stdlib.h>
// Определение структуры студента
// Примечание: необходимо использовать массив фиксированной длины, нельзя использовать член-указатель char *name
typedef struct {
int id; // Идентификатор студента
char name[50]; // Имя (фиксированный массив, указатель не допускается)
float score; // Оценка
} Student;
int main() {
// ===== Запись структуры в файл =====
Student s = {101, "Alice", 95.5f}; // Инициализация данных
FILE *fp = fopen("student.bin", "wb");
if (fp == NULL) {
perror("Не удалось открыть файл");
return 1;
}
// Записать всю структуру как один блок данных
size_t written = fwrite(&s, sizeof(Student), 1, fp);
if (written != 1) {
printf("Ошибка записи\n");
}
fclose(fp);
// ===== Чтение структуры из файла =====
fp = fopen("student.bin", "rb");
if (fp == NULL) {
perror("Не удалось открыть файл");
return 1;
}
Student loaded; // Не инициализировано, будет заполнено fread
size_t read_count = fread(&loaded, sizeof(Student), 1, fp);
if (read_count != 1) {
printf("Ошибка чтения или конец файла"\n");
fclose(fp);
return 1;
}
printf("ID: %d, Имя: %s, Оценка: %.1f\n", loaded.id, loaded.name, loaded.score);
fclose(fp);
return 0;
}
学号: 101, 姓名: Alice, 成绩: 95.5
Структуры не могут содержать члены-указатели (например,char *name), потому что fwrite сохраняет только значение адреса указателя, а не содержимое строки, на которую он указывает. При чтении обратно этот адрес больше не действителен, что приводит к висячему указателю. Правильная практика — использовать массив фиксированной длины, напримерchar name[50]。
Чтение и запись данных массива
Массивы хранятся в памяти непрерывно, поэтому весь массив можно прочитать или записать сразу.
Пример
int main() {
// Массив необработанных данных
int data[] = {1, 2, 3, 4, 5};
int count = 5; // Количество элементов массива
// ===== Запись массива в файл =====
FILE *fp = fopen("array.bin", "wb");
if (fp == NULL) {
perror("Не удалось открыть файл");
return 1;
}
// data эквивалентно &data[0], указывая на первый адрес массива
fwrite(data, sizeof(int), count, fp);
fclose(fp);
printf("Записано %d целых чисел в array.bin\n", count);
// ===== Чтение массива из файла =====
int buffer[5] = {0}; // Инициализация нулём для удобной проверки результатов чтения
fp = fopen("array.bin", "rb");
if (fp == NULL) {
perror("Не удалось открыть файл");
return 1;
}
size_t read_count = fread(buffer, sizeof(int), count, fp);
if (read_count < count) {
printf("Неполное чтение: ожидалось %d элементов, получено %zu элементов"\n", count, read_count);
}
fclose(fp);
// Вывести результат чтения
printf("Прочитанные данные: ");
for (int i = 0; i < count; i++) {
printf("%d ", buffer[i]);
}
printf("\n");
return 0;
}
已写入 5 个整数到 array.bin 读取到的数据: 1 2 3 4 5
Пакетное чтение и запись больших файлов
Для больших файлов следует использовать цикл для чтения/записи по частям, избегая загрузки всего содержимого в память сразу.
Пример
#include <stdlib.h>
#define BUFFER_SIZE 1024 // Чтение/запись по 1KB каждый раз, при необходимости настройте
// Эффективная функция копирования файла
// Возвращаемое значение: 0 означает успех, -1 означает ошибку
int copy_file(const char *src, const char *dst) {
char buffer[BUFFER_SIZE]; // Промежуточный буфер
FILE *in = fopen(src, "rb");
FILE *out = fopen(dst, "wb");
// Проверить, успешно ли открылись оба файла
if (!in) {
perror("Не удалось открыть исходный файл");
return -1;
}
if (!out) {
perror("Не удалось открыть целевой файл");
fclose(in); // Закрыть открытый исходный файл
return -1;
}
// Чтение в цикле, до BUFFER_SIZE байт каждый раз
size_t n;
while ((n = fread(buffer, 1, BUFFER_SIZE, in)) > 0) {
// fwrite с size=1, count=n гарантирует, что будет записано фактическое количество прочитанных байт
if (fwrite(buffer, 1, n, out) != n) {
perror("Ошибка записи");
fclose(in);
fclose(out);
return -1;
}
}
// Проверить, завершилось ли чтение из-за ошибки (а не из-за обычного EOF)
if (ferror(in)) {
perror("Ошибка чтения");
fclose(in);
fclose(out);
return -1;
}
fclose(in);
fclose(out);
printf("Файл успешно скопирован: %s -> %s\n"\n", src, dst);
return 0;
}
int main() {
// Пример использования: скопировать пример тестового файла
copy_file("example_input.bin", "example_output.bin");
return 0;
}
文件复制成功: example_input.bin -> example_output.bin
Ключ к этому режиму —freadвозвращает фактическое количество прочитанных байтов, затем используйтеfwrite, чтобы записать только фактически прочитанное количество байтов, избегая записи лишних данных в конце.
Ключевые моменты
Проверка возвращаемого значения
После вызова fread/fwrite необходимо проверять возвращаемое значение, чтобы отличать нормальное завершение от нештатных ситуаций.
Пример
int main() {
int buffer[100];
FILE *fp = fopen("data.bin", "rb");
if (fp == NULL) {
perror("Не удалось открыть файл");
return 1;
}
// Попробовать прочитать 100 целых чисел
size_t count = fread(buffer, sizeof(int), 100, fp);
if (count < 100) {
// Отличать EOF от ошибок
if (feof(fp)) {
printf("Достигнут конец файла, фактически прочитано %zu элементов\n"\n", count);
// На этом этапе мы можем продолжить обработку прочитанных данных
} else if (ferror(fp)) {
perror("Во время чтения произошла ошибка");
fclose(fp);
return 1;
}
} else {
printf("Успешно прочитаны все %zu элементов\n", count);
}
fclose(fp);
return 0;
}
已到达文件末尾,实际读取 47 个元素
Подводные камни чтения/записи структур
На размещение структур в памяти влияет стратегия выравнивания компилятора, что может вызвать проблемы с кросс-платформенной совместимостью.
Несогласованность выравнивания памяти
При разных компиляторах или разных параметрах компиляции одна и та же структура может иметь разное размещение в памяти.
Пример
// Пример проблемы: при выравнивании по умолчанию после char будет 3 байта заполнения
typedef struct {
char c; // Занимает 1 байт, но после него есть заполнение
int i; // Выравнивание по 4 байта, фактически начинается со смещения 4
} Mixed;
// Решение 1: использовать pragma pack, чтобы принудительно задать компактное выравнивание
#pragma pack(push, 1) // Сохранить текущие настройки выравнивания, установить выравнивание по 1 байту
typedef struct {
char c; // Смещение 0, занимает 1 байт
int i; // Смещение 1, занимает 4 байта (без заполнения)
} PackedMixed;
#pragma pack(pop) // Восстановить предыдущие настройки выравнивания
// Решение 2: вручную сериализовать члены по одному (самый безопасный способ)
// Этот метод не зависит от выравнивания компилятора и обеспечивает наилучшую кроссплатформенную совместимость
int main() {
// Вывести разницу размеров между двумя структурами
printf("Размер Mixed при выравнивании по умолчанию: %zu байт\n", sizeof(Mixed)); // Обычно 8
printf("Размер PackedMixed с компактным выравниванием: %zu байт\n", sizeof(PackedMixed)); // Это 5
return 0;
}
默认对齐 Mixed 大小: 8 字节 紧凑对齐 PackedMixed 大小: 5 字节
Рекомендуемая практикаДля кроссплатформенного или долговременного хранения предпочитайте ручную сериализацию (чтение/запись каждого члена) прямому записыванию структуры в файл. Это позволяет полностью избежать проблем с выравниванием и порядком байтов.
Члены-указатели запрещены
Это одна из самых распространённых ошибок, допускаемых новичками.
Пример
#include <string.h>
#include <stdlib.h>
// Неправильный пример: структура содержит член-указатель
typedef struct {
int id;
char *name; // Опасно! fwrite сохраняет только значение указателя (адрес), а не содержимое строки
} BadStudent;
// Правильный пример: используйте массив фиксированного размера
typedef struct {
int id;
char name[100]; // Фактические данные хранятся в структуре, поэтому их можно безопасно читать и записывать
} GoodStudent;
int main() {
// Демонстрация последствий неправильного подхода
BadStudent bs;
bs.id = 1;
bs.name = malloc(50);
strcpy(bs.name, "EXAMPLE");
// Запись BadStudent: на этом этапе записывается адрес указателя name, но содержимое строки не записывается
FILE *fp = fopen("bad.bin", "wb");
fwrite(&bs, sizeof(BadStudent), 1, fp);
fclose(fp);
// Обратное чтение BadStudent: значение указателя name — это адрес из предыдущего malloc в другом процессе, полностью недействительный
BadStudent загружен;
fp = fopen("bad.bin", "rb");
fread(&loaded, sizeof(BadStudent), 1, fp);
fclose(fp);
// loaded.name — висячий указатель; обращение к нему приводит к неопределённому поведению!
free(bs.name);
printf("Демонстрация завершена, но загруженный указатель name недействителен"\n");
return 0;
}
演示完成,但 load 出来的 name 指针是无效的
Сброс буфера
Ввод-вывод стандартной библиотеки C буферизован; критически важные данные нужно явно сбрасывать для обеспечения сохранности.
Пример
int main() {
FILE *fp = fopen("critical.bin", "wb");
if (fp == NULL) {
perror("Не удалось открыть файл");
return 1;
}
int data[] = {1, 2, 3, 4, 5};
fwrite(data, sizeof(int), 5, fp);
// Способ 1: явно сбросить буфер, данные немедленно записываются на диск
fflush(fp);
printf("Используйте fflush, чтобы принудительно сбросить данные на диск\n");
// Способ 2: Автоматический сброс при закрытии файла (рекомендуется)
// fclose автоматически вызывает fflush внутри
fclose(fp);
printf("fclose также автоматически сбрасывает буфер\n");
return 0;
}
使用 fflush 强制刷新到磁盘 fclose 也会自动刷新缓冲区
Позиционирование указателя файла
Сочетание fseek и ftell обеспечивает произвольный доступ к файлу, позволяя при необходимости считывать данные в указанных позициях.
Пример
typedef struct {
int id;
char name[50];
float score;
} Student;
int main() {
FILE *fp = fopen("students.bin", "rb");
if (fp == NULL) {
perror("Не удалось открыть файл");
return 1;
}
// Перейти в конец файла, чтобы получить размер файла
fseek(fp, 0, SEEK_END);
long file_size = ftell(fp);
printf("Размер файла: %ld bytes\n", file_size);
// Вычислить количество записей struct в файле
long record_count = file_size / sizeof(Student);
printf("Содержит %ld студенческих записей\n", record_count);
// Перейти к 6-й структуре (индекс начинается с 0, смещение = 5 * sizeof(Student))
fseek(fp, sizeof(Student) * 5, SEEK_SET);
Student s;
fread(&s, sizeof(Student), 1, fp);
printf("Запись #6: id=%d, name=%s\n", s.id, s.name);
fclose(fp);
return 0;
}
文件大小: 6000 字节 包含 100 条学生记录 第 6 条记录: id=106, name=EXAMPLE
Сводка распространённых ошибок
В следующей таблице обобщены наиболее распространённые проблемы и правильные приёмы при использовании fread/fwrite:
| Тип ошибки | Симптом ошибки | Правильный подход |
|---|---|---|
| Непроверенный указатель файла | Вызов fread сразу после неудачного fopen приводит к сбою. | Всегда проверяйтеfp != NULL |
| Игнорирование двоичного режима | Двоичные данные повреждаются из-за преобразования символов новой строки в Windows. | Использование"rb" / "wb" |
| Путаница между количеством блоков и количеством байтов | Интерпретация возвращаемого значения как количества байтов приводит к логическим ошибкам. | Помните, что возвращаемое значение — это количество блоков; количество байтов =Возвращаемое значение × size |
| Переполнение буфера | Недостаточно выделенного места, запись за границы | Обеспечьте достаточный объём буфера ≥size × count |
| Структура содержит указатели | Адрес указателя недействителен после обратного чтения, что приводит к висячему указателю. | Используйте фиксированный массив или вручную сериализуйте каждый член. |
| Игнорирование проверок ошибок | Неспособность отличить EOF от ошибок чтения, что приводит к неполным данным. | Проверьте возвращаемое значение, используйтеfeof() / ferror()Определите причину |
| Данные не синхронизированы | Сбой программы приводит к потере данных буфера | После записи важных данных вызовитеfflush(fp) |