Раздел 14 — Двоичные файлы

В разделе 13 записи хранились текстом: Ivanov;21V;4.75. Такой файл читает человек и любая программа, но у него два недостатка. Строки разной длины — чтобы найти сотую запись, надо прочитать 99 предыдущих. И число при записи переводится в текст и обратно: %.2f округляет, и прочитанное значение может отличаться от записанного.

Двоичный файл хранит байты памяти как есть: структура Student занимает в файле ровно sizeof(Student) байтов, как в памяти. Все записи одного размера — запись номер i начинается с байта i * sizeof(Student), и до неё можно «перепрыгнуть». Число не переводится в текст — читается тем же, каким было записано.

fwrite(адрес, размер элемента, количество, файл) записывает подряд количество элементов по размер байтов, начиная с адреса. fread с теми же параметрами читает. Обе возвращают число полностью записанных или прочитанных элементов — не байтов:

/* Записать n записей в файл path; 0 — успех, 1 — ошибка */
int save(const char *path, const Student a[], int n)
{
    FILE *f = fopen(path, "wb");
    if (f == NULL) {
        perror(path);
        return 1;
    }
    size_t written = fwrite(a, sizeof a[0], (size_t)n, f);
    if (fclose(f) != 0 || written != (size_t)n) {
        fprintf(stderr, "%s: write error\n", path);
        return 1;
    }
    return 0;
}

/* Прочитать не больше max записей; число прочитанных или -1 */
int load(const char *path, Student a[], int max)
{
    FILE *f = fopen(path, "rb");
    if (f == NULL) {
        perror(path);
        return -1;
    }
    size_t n = fread(a, sizeof a[0], (size_t)max, f);
    if (ferror(f)) {
        fprintf(stderr, "%s: read error\n", path);
        n = 0;
    }
    fclose(f);
    return (int)n;
}

Программа examples/14/records.c записывает трёх студентов, узнаёт размер файла (как — в пункте 4) и читает их обратно:

sizeof(Student) = 64, file 192 bytes, 3 records
0: Ivanov   21V  4.75
1: Petrova  21V  3.80
2: Sidorov  22V  4.50

• fread просит до max записей, а возвращает, сколько было в файле, — так загружается файл неизвестной длины. Результат меньше запрошенного означает конец файла или ошибку; что именно — скажет ferror (пункт 6).
• При записи результат fclose тоже проверяют: данные лежат в буфере и уходят на диск при закрытии — ошибка «диск заполнен» может проявиться только там.
• В двоичный файл нельзя писать указатели: в файл попадёт адрес, а не то, на что он указывает, и при следующем запуске адрес ничего не значит. Поэтому строки в записи — массивы char фиксированного размера, а не char *.

Посмотрим на первые 64 байта students.dat — одну запись — программой hexdump из пункта 5. Слева смещение, в середине байты в шестнадцатеричном виде, справа они же символами (непечатные — точкой):

00000000  49 76 61 6e 6f 76 00 00 00 00 00 00 00 00 00 00  |Ivanov..........|
00000010  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  |................|
00000020  00 00 00 00 00 00 00 00 00 32 31 56 00 00 00 00  |.........21V....|
00000030  00 00 00 00 00 00 00 00 00 00 00 00 00 00 13 40  |...............@|

• Байты 0–40 — поле name[41]: Ivanov, '\0' и остаток массива. Массив пишется целиком, даже пустая его часть.
• Байты 41–51 — group[11]: 21V с 0x29.
• Байты 52–55 — выравнивание: поля нет, компилятор вставил 4 байта, чтобы double начинался с адреса, кратного 8. Поэтому sizeof(Student) = 64, а не 41 + 11 + 8 = 60.
• Байты 56–63 — score = 4.75. Это 0x4013000000000000, а в файле 00 … 00 13 40: процессоры x86 и ARM хранят число младшим байтом вперёд (little-endian).

У открытого файла есть текущая позиция — номер байта, с которого начнётся следующее чтение или запись. После каждого fread и fwrite она сдвигается на обработанные байты. Позицию можно поставить вручную:

Запись номер index начинается с байта index * sizeof(Student), число записей — размер файла, делённый на sizeof(Student). Чтобы изменить одну запись, файл открывают режимом "r+b" — чтение и запись без стирания — и пишут запись на её место:

/* Прочитать запись номер index; false — такой записи нет */
bool read_record(FILE *f, long index, Student *s)
{
    if (fseek(f, index * (long)sizeof *s, SEEK_SET) != 0) {
        return false;
    }
    return fread(s, sizeof *s, 1, f) == 1;
}

/* Записать запись номер index на её место */
bool write_record(FILE *f, long index, const Student *s)
{
    if (fseek(f, index * (long)sizeof *s, SEEK_SET) != 0) {
        return false;
    }
    return fwrite(s, sizeof *s, 1, f) == 1;
}

$ ./direct students.dat 1 4.10
before: Petrova 21V 3.80
after:  Petrova 21V 4.10
$ ./direct students.dat 5 4.10
No record 5

• fseek за конец файла ошибкой не считается — ошибку покажет fread, который вернёт 0. Поэтому «нет записи 5» определяется по результату чтения.
• Запись за концом файла (fseek на n * sizeof и fwrite) дописывает запись; дальше конца — оставляет «дыру» из нулей. Новые записи добавляют в конец.
• В режиме "r+b" между чтением и записью (и наоборот) обязателен fseek или fflush — так требует стандарт C. В функциях выше fseek стоит перед каждой операцией, и правило выполняется само.
• Удалить запись из середины двоичного файла нельзя — только переписать файл без неё. Часто вместо удаления ставят в записи признак «удалена» и пропускают такие записи при выводе.

Любой файл — картинка, архив, exe — это последовательность байтов. Программа, которая не знает его формат, может читать его по байтам: fgetc(f) возвращает очередной байт как число 0…255 или EOF (−1) в конце. Результат хранят в int, не в char: иначе байт 0xFF станет равен EOF и чтение оборвётся на нём.

int c;
while (offset < limit && (c = fgetc(f)) != EOF) {   /* c — int: EOF не равен ни одному байту */
    line[used++] = (unsigned char)c;
    offset++;
    if (used == PER_LINE) {
        print_line(offset - used, line, used);
        used = 0;
    }
}

Это цикл программы hexdump (examples/14/hexdump.c), печатающей дамп из пункта 3. На текстовом файле из одной строки Hi! видно, что перевод строки — тоже байт, 0a:

00000000  48 69 21 0a                                      |Hi!.|

Для больших файлов fgetc медленнее чтения блоками: копирование читает fread по 4096 байтов с размером элемента 1 — тогда результат fread равен числу байтов, и последний неполный блок не теряется:

unsigned char buffer[4096];
size_t n;
while ((n = fread(buffer, 1, sizeof buffer, in)) > 0) {
    if (fwrite(buffer, 1, n, out) != n) {
        /* ошибка записи: сообщить, закрыть оба файла, вернуть 1 */
    }
    total += (long long)n;
}

Формат файла определяют не по расширению, а по сигнатуре — первым байтам, которые формат требует:

Программа examples/14/filecopy.c копирует файл и сравнивает его первые байты с таблицей через memcmp:

$ ./filecopy students.dat copy.dat
192 bytes copied, type: unknown
$ ./filecopy fake.png fake2.png
8 bytes copied, type: PNG image
$ ./filecopy missing.bin x.bin
missing.bin: No such file or directory

Байты PNG 0D 0A и 1A выбраны нарочно: файл, скопированный в текстовом режиме Windows, сразу видно по испорченной сигнатуре (пункт 1).

Цикл чтения заканчивается, когда fread вернул меньше запрошенного или fgetc вернул EOF. Причин две: данные кончились или чтение сломалось (диск, сеть, флешку вынули). Различают их после цикла:

int failed = ferror(in);
fclose(in);
if (fclose(out) != 0 || failed) {
    fprintf(stderr, "Copy failed\n");
    return 1;
}

Как и в разделе 13, feof — не условие цикла: он становится истинным только после неудачного чтения. Условие цикла — результат самой функции чтения, а feof и ferror отвечают на вопрос «почему цикл кончился».