НТВ плюс 

Как прочитать бинарный файл? Бинарный файл

Вероятно, вы уже встречали понятия «текстовый» и «бинарный», читая какие-нибудь статьи о файлах . И решили, что всё это для вас слишком сложно, вовек не разобраться, поэтому не стали вникать, махнув на это рукой.

Мы же попытаемся растолковать всё максимально простым языком, ведь такие сведения полезны для каждого пользователя , даже самого неискушённого, потому что имеют непосредственное отношение к азам компьютерной безопасности .

Немного теории

Текстовый файл содержит в себе символы ASCII (аббревиатура расшифровывается как American Standard Code for Information Interchange, что-то вроде «американский стандарт кодировки для обмена информацией »).

Фактически ASCII - это таблица, в которой каждой букве, цифре, знаку пунктуации и разным «собакам» со «снежинками» (в смысле, @ и *) выделено по одному байту. То бишь, по восемь нулей и единиц (бит) . Плюс, конечно, управляющие символы вроде перехода к новой строке.

Программа для открытия файлов с символами ASCII преобразовывает байты в буквы, цифры и прочие печатные знаки на дисплее . Конечно, софт должен понимать ту часть таблицы, которая соответствует русскому языку, но это уже вопрос кодировки.

В бинарном файле нули и единицы выстраиваются в последовательности, которые нужны необязательно для отображения текстов (хотя есть и такие, например, *doc). А для чего же, спросите вы. Ответ прост: для всего остального. Программы, фильмы, музыка, изображения - у каждого формата свои структурные принципы организации данных.

Само слово «бинарный» означает «состоящий из двух компонентов», «двойной». Действительно, чётко определить получается только два компонента - ноль и единицу, биты, «кирпичики», из которых сложен файл. Смысл всего остального может проявляться только во время запуска (открытия, воспроизведения).

Изнанка цифрового мира

Заглянуть внутрь бинарного файла можно с помощью специальной программы - HEX-редактора. (От слова Hexadecimal, обозначающего шестнадцатеричную систему счисления.) Такой софт показывает байты в виде их HEX-обозначений, расположенных фактически тоже в виде таблицы (матрицы).

К примеру, байты изображения в формате JPEG, обычной картинки или фотографии, в окошке редактора будут показаны как FF D8 FF 00 04 3A 29 и так далее.

Специалист поймёт, что последовательность байт FF D8 в самом начале указывает на то, что перед нами - именно JPEG. А неспециалистам всё это не так уж интересно.

В HEX-редакторе можно открыть и текстовый файл, чтобы увидеть, какие байты соответствуют конкретным буквам (символам ASCII). Но только разве что из любопытства, всё равно смысла в этом нет.

А вот бинарные файлы, бывает, просматривают в шестнадцатеричном виде с вполне осмысленно и конкретными целями. Например, специалисты антивирусных лабораторий таким образом ищут вредоносный код, дописанный к основному. Кстати, переходим к вопросам безопасности.

Что способно навредить

Текстовый файл не может содержать ничего, кроме символов ASCII. Однако программы бывают не только бинарными, но и состоящими из вышеуказанных символов. Имеются ввиду скрипты, конечно.

Иными словами, файл *txt не заражается в принципе и угрозы не представляет. А если внутри текстового файла - скрипт, то бед натворить он способен немало.

К примеру, файл *bat содержит код разных команд и запускается двойным кликом, как обычная программа. Написаны те команды символами ASCII, но операционная система умеет их интерпретировать - превращать в такие нули и единицы, какие характерны именно для программ.

Но вы, конечно, не жмёте на неведомые bat-файлы, правда? Вот и хорошо.

Предыдущие публикации:

Последнее редактирование: 2012-11-06 14:45:16

Метки материала: ,

Теги: Бинарные файлы, fseek, ftell, fpos, fread, fwrite

Бинарные файлы

Т екстовые файлы хранят данные в виде текста (sic!). Это значит, что если, например, мы записываем целое число 12345678 в файл, то записывается 8 символов, а это 8 байт данных, несмотря на то, что число помещается в целый тип. Кроме того, вывод и ввод данных является форматированным, то есть каждый раз, когда мы считываем число из файла или записываем в файл происходит трансформация числа в строку или обратно. Это затратные операции, которых можно избежать.

Текстовые файлы позволяют хранить информацию в виде, понятном для человека. Можно, однако, хранить данные непосредственно в бинарном виде. Для этих целей используются бинарные файлы.

#include #include #include #define ERROR_FILE_OPEN -3 void main() { FILE *output = NULL; int number; output = fopen("D:/c/output.bin", "wb"); if (output == NULL) { printf("Error opening file"); getch(); exit(ERROR_FILE_OPEN); } scanf("%d", &number); fwrite(&number, sizeof(int), 1, output); fclose(output); _getch(); }

Выполните программу и посмотрите содержимое файла output.bin. Число, которое ввёл пользователь записывается в файл непосредственно в бинарном виде. Можете открыть файл в любом редакторе, поддерживающем представление в шестнадцатеричном виде (Total Commander, Far) и убедиться в этом.

Запись в файл осуществляется с помощью функции

Size_t fwrite (const void * ptr, size_t size, size_t count, FILE * stream);

Функция возвращает число удачно записанных элементов. В качестве аргументов принимает указатель на массив, размер одного элемента, число элементов и указатель на файловый поток. Вместо массив, конечно, может быть передан любой объект.

Запись в бинарный файл объекта похожа на его отображение: берутся данные из оперативной памяти и пишутся как есть. Для считывания используется функция fread

Size_t fread (void * ptr, size_t size, size_t count, FILE * stream);

Функция возвращает число удачно прочитанных элементов, которые помещаются по адресу ptr. Всего считывается count элементов по size байт. Давайте теперь считаем наше число обратно в переменную.

#include #include #include #define ERROR_FILE_OPEN -3 void main() { FILE *input = NULL; int number; input = fopen("D:/c/output.bin", "rb"); if (input == NULL) { printf("Error opening file"); getch(); exit(ERROR_FILE_OPEN); } fread(&number, sizeof(int), 1, input); printf("%d", number); fclose(input); _getch(); }

fseek

Одной из важных функций для работы с бинарными файлами является функция fseek

Int fseek (FILE * stream, long int offset, int origin);

Эта функция устанавливает указатель позиции, ассоциированный с потоком, на новое положение. Индикатор позиции указывает, на каком месте в файле мы остановились. Когда мы открываем файл, позиция равна 0. Каждый раз, записывая байт данных, указатель позиции сдвигается на единицу вперёд.
fseek принимает в качестве аргументов указатель на поток и сдвиг в offset байт относительно origin. origin может принимать три значения

  • SEEK_SET - начало файла
  • SEEK_CUR - текущее положение файла
  • SEEK_END - конец файла. К сожалению, стандартом не определено, что такое конец файла, поэтому полагаться на эту функцию нельзя.

В случае удачной работы функция возвращает 0.

Дополним наш старый пример: запишем число, затем сдвинемся указатель на начало файла и прочитаем его.

#include #include #include #define ERROR_FILE_OPEN -3 void main() { FILE *iofile = NULL; int number; iofile = fopen("D:/c/output.bin", "w+b"); if (iofile == NULL) { printf("Error opening file"); getch(); exit(ERROR_FILE_OPEN); } scanf("%d", &number); fwrite(&number, sizeof(int), 1, iofile); fseek(iofile, 0, SEEK_SET); number = 0; fread(&number, sizeof(int), 1, iofile); printf("%d", number); fclose(iofile); _getch(); }

Вместо этого можно также использовать функцию rewind, которая перемещает индикатор позиции в начало.

В си определён специальный тип fpos_t, который используется для хранения позиции индикатора позиции в файле.
Функция

Int fgetpos (FILE * stream, fpos_t * pos);

используется для того, чтобы назначить переменной pos текущее положение. Функция

Int fsetpos (FILE * stream, const fpos_t * pos);

используется для перевода указателя в позицию, которая хранится в переменной pos. Обе функции в случае удачного завершения возвращают ноль.

Long int ftell (FILE * stream);

возвращает текущее положение индикатора относительно начала файла. Для бинарных файлов - это число байт, для текстовых не определено (если текстовый файл состоит из однобайтовых символов, то также число байт).

Рассмотрим пример: пользователь вводит числа. Первые 4 байта файла: целое, которое обозначает, сколько чисел было введено. После того, как пользователь прекращает вводить числа, мы перемещаемся в начало файла и записываем туда число введённых элементов.

#include #include #include #define ERROR_OPEN_FILE -3 void main() { FILE *iofile = NULL; unsigned counter = 0; int num; int yn; iofile = fopen("D:/c/numbers.bin", "w+b"); if (iofile == NULL) { printf("Error opening file"); getch(); exit(ERROR_OPEN_FILE); } fwrite(&counter, sizeof(int), 1, iofile); do { printf("enter new number? "); scanf("%d", &yn); if (yn == 1) { scanf("%d", &num); fwrite(&num, sizeof(int), 1, iofile); counter++; } else { rewind(iofile); fwrite(&counter, sizeof(int), 1, iofile); break; } } while(1); fclose(iofile); getch(); }

Вторая программа сначала считывает количество записанных чисел, а потом считывает и выводит числа по порядку.

#include #include #include #define ERROR_OPEN_FILE -3 void main() { FILE *iofile = NULL; unsigned counter; int i, num; iofile = fopen("D:/c/numbers.bin", "rb"); if (iofile == NULL) { printf("Error opening file"); getch(); exit(ERROR_OPEN_FILE); } fread(&counter, sizeof(int), 1, iofile); for (i = 0; i < counter; i++) { fread(&num, sizeof(int), 1, iofile); printf("%d\n", num); } fclose(iofile); getch(); }

Примеры

1. Имеется бинарный файл размером 10*sizeof(int) байт. Пользователь вводит номер ячейки, после чего в неё записывает число. После каждой операции выводятся все числа. Сначала пытаемся открыть файл в режиме чтения и записи. Если это не удаётся, то пробуем создать файл, если удаётся создать файл, то повторяем попытку открыть файл для чтения и записи.

#include #include #include #define SIZE 10 void main() { const char filename = "D:/c/state"; FILE *bfile = NULL; int pos; int value = 0; int i; char wasCreated; do { wasCreated = 0; bfile = fopen(filename, "r+b"); if (NULL == bfile) { printf("Try to create file...\n"); getch(); bfile = fopen(filename, "wb"); if (bfile == NULL) { printf("Error when create file"); getch(); exit(1); } for (i = 0; i < SIZE; i++) { fwrite(&value, sizeof(int), 1, bfile); } printf("File created successfully...\n"); fclose(bfile); wasCreated = 1; } } while(wasCreated); do { printf("Enter position "); scanf("%d", &pos); if (pos < 0 || pos >= SIZE) { break; } printf("Enter value "); scanf("%d", &value); fseek(bfile, pos*sizeof(int), SEEK_SET); fwrite(&value, sizeof(int), 1, bfile); rewind(bfile); for (i = 0; i < SIZE; i++) { fread(&value, sizeof(int), 1, bfile); printf("%d ", value); } printf("\n"); } while(1); fclose(bfile); }

2. Пишем слова в бинарный файл. Формат такой - сначало число букв, потом само слово без нулевого символа. Ели длина слова равна нулю, то больше слов нет. Сначала запрашиваем слова у пользователя, потом считываем обратно.

#include #include #include #include #define ERROR_FILE_OPEN -3 void main() { const char filename = "C:/c/words.bin"; const char termWord = "exit"; char buffer; unsigned int len; FILE *wordsFile = NULL; printf("Opening file...\n"); wordsFile = fopen(filename, "w+b"); if (wordsFile == NULL) { printf("Error opening file"); getch(); exit(ERROR_FILE_OPEN); } printf("Enter words\n"); do { scanf("%127s", buffer); if (strcmp(buffer, termWord) == 0) { len = 0; fwrite(&len, sizeof(unsigned), 1, wordsFile); break; } len = strlen(buffer); fwrite(&len, sizeof(unsigned), 1, wordsFile); fwrite(buffer, 1, len, wordsFile); } while(1); printf("rewind and read words\n"); rewind(wordsFile); getch(); do { fread(&len, sizeof(int), 1, wordsFile); if (len == 0) { break; } fread(buffer, 1, len, wordsFile); buffer = "\0"; printf("%s\n", buffer); } while(1); fclose(wordsFile); getch(); }

3. Задача - считать данные из текстового файла и записать их в бинарный. Для решения зачи создадим функцию обёртку. Она будет принимать имя файла, режим доступа, функцию, которую необходимо выполнить, если файл был удачно открыт и аргументы этой функции. Так как аргументов может быть много и они могут быть разного типа, то их можно передавать в качестве указателя на структуру. После выполнения функции файл закрывается. Таким образом, нет необходимости думать об освобождении ресурсов.

#include #include #include #define DEBUG #ifdef DEBUG #define debug(data) printf("%s", data); #else #define debug(data) #endif const char inputFile = "D:/c/xinput.txt"; const char outputFile = "D:/c/output.bin"; struct someArgs { int* items; size_t number; }; int writeToFile(FILE *file, void* args) { size_t i; struct someArgs *data = (struct someArgs*) args; debug("write to file\n") fwrite(data->items, sizeof(int), data->number, file); debug("write finished\n") return 0; } int readAndCallback(FILE *file, void* args) { struct someArgs data; size_t size, i = 0; int result; debug("read from file\n") fscanf(file, "%d", &size); data.items = (int*) malloc(size*sizeof(int)); data.number = size; while (!feof(file)) { fscanf(file, "%d", &data.items[i]); i++; } debug("call withOpenFile\n") result = withOpenFile(outputFile, "w", writeToFile, &data); debug("read finish\n") free(data.items); return result; } int doStuff() { return withOpenFile(inputFile, "r", readAndCallback, NULL); } //Обёртка - функция открывает файл. Если файл был благополучно открыт, //то вызывается функция fun. Так как аргументы могут быть самые разные, //то они передаются через указатель void*. В качестве типа аргумента //разумно использовать структуру int withOpenFile(const char *filename, const char *mode, int (*fun)(FILE* source, void* args), void* args) { FILE *file = fopen(filename, mode); int err; debug("try to open file ") debug(filename) debug("\n") if (file != NULL) { err = fun(file, args); } else { return 1; } debug("close file ") debug(filename) debug("\n") fclose(file); return err; } void main() { printf("result = %d", doStuff()); getch(); }

4. Функция saveInt32Array позволяет сохранить массив типа int32_t в файл. Обратная ей loadInt32Array считывает массив обратно. Функция loadInt32Array сначала инициализирует переданный ей массив, поэтому мы должны передавать указатель на указатель; кроме того, она записывает считанный размер массива в переданный параметр size, из-за чего он передаётся как указатель.

#include #include #include #include #define SIZE 100 int saveInt32Array(const char *filename, const int32_t *a, size_t size) { FILE *out = fopen(filename, "wb"); if (!out) { return 0; } //Записываем длину массива fwrite(&size, sizeof(size_t), 1, out); //Записываем весь массив fwrite(a, sizeof(int32_t), size, out); fclose(out); return 1; } int loadInt32Array(const char *filename, int32_t **a, size_t *size) { FILE *in = fopen(filename, "rb"); if (!in) { return 0; } //Считываем длину массива fread(size, sizeof(size_t), 1, in); //Инициализируем массив (*a) = (int32_t*) malloc(sizeof(int32_t) * (*size)); if (!(*a)) { return 0; } //Считываем весь массив fread((*a), sizeof(int32_t), *size, in); fclose(in); return 1; } void main() { const char *tmpFilename = "tmp.bin"; int32_t exOut; int32_t *exIn = NULL; size_t realSize; int i; for (i = 0; i < SIZE; i++) { exOut[i] = i*i; } saveInt32Array(tmpFilename, exOut, SIZE); loadInt32Array(tmpFilename, &exIn, &realSize); for (i = 0; i < realSize; i++) { printf("%d ", exIn[i]); } _getch(); }

5. Создание таблицы поиска. Для ускорения работы программы вместо вычисления функции можно произвести сначала вычисление значений функции на интервале с определённой точностью, после чего брать значения уже из таблицы. Программа сначала производит табулирование функции с заданными параметрами и сохраняет его в файл, затем подгружает предвычисленный массив, который уже используется для определения значений. В этой программе все функции возвращают переменную типа Result, которая хранит номер ошибки. Если функция отработала без проблем, то она возвращает Ok (0).

#define _CRT_SECURE_NO_WARNINGS //Да, это теперь обязательно добавлять, иначе не заработает #include #include #include #include #include //Каждая функция возвращает результат. Если он равен Ok, то функция //отработала без проблем typedef int Result; //Возможные результаты работы #define Ok 0 #define ERROR_OPENING_FILE 1 #define ERROR_OUT_OF_MEMORY 2 //Функция, которую мы будем табулировать double mySinus(double x) { return sin(x); } Result tabFunction(const char *filename, double from, double to, double step, double (*f)(double)) { Result r; FILE *out = fopen(filename, "wb"); double value; if (!out) { r = ERROR_OPENING_FILE; goto EXIT; } fwrite(&from, sizeof(from), 1, out); fwrite(&to, sizeof(to), 1, out); fwrite(&step, sizeof(step), 1, out); for (from; from < to; from += step) { value = f(from); fwrite(&value, sizeof(double), 1, out); } r = Ok; EXIT: fclose(out); return r; } Result loadFunction(const char *filename, double **a, double *from, double *to, double *step) { Result r; uintptr_t size; FILE *in = fopen(filename, "rb"); if (!in) { r = ERROR_OPENING_FILE; goto EXIT; } //Считываем вспомогательную информацию fread(from, sizeof(*from), 1, in); fread(to, sizeof(*to), 1, in); fread(step, sizeof(*step), 1, in); //Инициализируем массив size = (uintptr_t) ((*to - *from) / *step); (*a) = (double*) malloc(sizeof(double)* size); if (!(*a)) { r = ERROR_OUT_OF_MEMORY; goto EXIT; } //Считываем весь массив fread((*a), sizeof(double), size, in); r = Ok; EXIT: fclose(in); return r; } void main() { const char *tmpFilename = "tmp.bin"; Result r; double *exIn = NULL; int accuracy, option; double from, to, step, arg; uintptr_t index; //Запрашиваем параметры для создания таблицы поиска printf("Enter parameters\nfrom = "); scanf("%lf", &from); printf("to = "); scanf("%lf", &to); printf("step = "); scanf("%lf", &step); r = tabFunction(tmpFilename, from, to, step, mySinus); if (r != Ok) { goto CATCH_SAVE_FUNCTION; } //Обратите внимание на формат вывода. Точность определяется //во время работы программы. Формат * подставит значение точности, //взяв его из списка аргументов accuracy = (int) (-log10(step)); printf("function tabulated from %.*lf to %.*lf with accuracy %.*lf\n", accuracy, from, accuracy, to, accuracy, step); r = loadFunction(tmpFilename, &exIn, &from, &to, &step); if (r != Ok) { goto CATCH_LOAD_FUNCTION; } accuracy = (int)(-log10(step)); do { printf("1 to enter values, 0 to exit: "); scanf("%d", &option); if (option == 0) { break; } else if (option != 1) { continue; } printf("Enter value from %.*lf to %.*lf: ", accuracy, from, accuracy, to); scanf("%lf", &arg); if (arg < from || arg > to) { printf("bad value\n"); continue; } index = (uintptr_t) ((arg - from) / step); printf("saved %.*lf\ncomputed %.*lf\n", accuracy, exIn, accuracy, mySinus(arg)); } while (1); r = Ok; goto EXIT; CATCH_SAVE_FUNCTION: { printf("Error while saving values"); goto EXIT; } CATCH_LOAD_FUNCTION: { printf("Error while loading values"); goto EXIT; } EXIT: free(exIn); _getch(); exit(r); }

6. У нас имеются две структуры. Первая PersonKey хранит логин, пароль, id пользователя и поле offset. Вторая структура PersonInfo хранит имя и фамилию пользователя и его возраст. Первые структуры записываются в бинарный файл keys.bin, вторые структуры в бинарный файл values.bin. Поле offset определяет положение соответствующей информации о пользователе во втором файле. Таким образом, получив PersonKey из первого файла, по полю offset можно извлечь из второго файла связанную с данным ключом информацию.

Зачем так делать? Это выгодно в том случае, если структура PersonInfo имеет большой размер. Извлекать массив маленьких структур из файла не накладно, а когда нам понадобится большая структура, её можно извлечь по уже известному адресу в файле.

#define _CRT_SECURE_NO_WARNINGS #include #include #include #include typedef struct PersonKey { long long id; char login; char password; long offset;//Положение соответствующих значений PersonInfo } PersonKey; typedef struct PersonInfo { unsigned age; char firstName; char lastName; } PersonInfo; /* Функция запрашивает у пользователя данные и пишет их подряд в два файла */ void createOnePerson(FILE *keys, FILE *values) { static long long id = 0; PersonKey pkey; PersonInfo pinfo; pkey.id = id++; //Так как все значения пишутся друг за другом, то текущее положение //указателя во втором файле будет позицией для новой записи pkey.offset = ftell(values); printf("Login: "); scanf("%63s", pkey.login); printf("Password: "); scanf("%63s", pkey.password); printf("Age: "); scanf("%d", &(pinfo.age)); printf("First Name: "); scanf("%63s", pinfo.firstName); printf("Last Name: "); scanf("%127s", pinfo.lastName); fwrite(&pkey, sizeof(pkey), 1, keys); fwrite(&pinfo, sizeof(pinfo), 1, values); } void createPersons(FILE *keys, FILE *values) { char buffer; int repeat = 1; int counter = 0;//Количество элементов в файле //Резервируем место под запись числа элементов fwrite(&counter, sizeof(counter), 1, keys); printf("CREATE PERSONS\n"); do { createOnePerson(keys, values); printf("\nYet another one? "); scanf("%1s", buffer); counter++; if (buffer != "y" && buffer != "Y") { repeat = 0; } } while(repeat); //Возвращаемся в начало и пишем количество созданных элементов rewind(keys); fwrite(&counter, sizeof(counter), 1, keys); } /* Создаём массив ключей */ PersonKey* readKeys(FILE *keys, int *size) { int i; PersonKey *out = NULL; rewind(keys); fread(size, sizeof(*size), 1, keys); out = (PersonKey*) malloc(*size * sizeof(PersonKey)); fread(out, sizeof(PersonKey), *size, keys); return out; } /* Функция открывает сразу два файла. Чтобы упростить задачу, возвращаем массив файлов. */ FILE** openFiles(const char *keysFilename, const char *valuesFilename) { FILE **files = (FILE**)malloc(sizeof(FILE*)*2); files = fopen(keysFilename, "w+b"); if (!files) { return NULL; } files = fopen(valuesFilename, "w+b"); if (!files) { fclose(files); return NULL; } return files; } /* Две вспомогательные функции для вывода ключа и информации */ void printKey(PersonKey pk) { printf("%d. %s [%s]\n", (int)pk.id, pk.login, pk.password); } void printInfo(PersonInfo info) { printf("%d %s %s\n", info.age, info.firstName, info.lastName); } /* Функция по ключу (вернее, по его полю offset) достаёт нужное значение из второго файла */ PersonInfo readInfoByPersonKey(PersonKey pk, FILE *values) { PersonInfo out; rewind(values); fseek(values, pk.offset, SEEK_SET); fread(&out, sizeof(PersonInfo), 1, values); return out; } void getPersonsInfo(PersonKey *keys, FILE *values, int size) { int index; PersonInfo p; do { printf("Enter position of element. To exit print bad index: "); scanf("%d", &index); if (index < 0 || index >= size) { printf("Bad index"); return; } p = readInfoByPersonKey(keys, values); printInfo(p); } while (1); } void main() { int size; int i; PersonKey *keys = NULL; FILE **files = openFiles("C:/c/keys.bin", "C:/c/values.bin"); if (files == 0) { printf("Error opening files"); goto FREE; } createPersons(files, files); keys = readKeys(files, &size); for (i = 0; i < size; i++) { printKey(keys[i]); } getPersonsInfo(keys, files, size); fclose(files); fclose(files); FREE: free(files); free(keys); _getch(); }

У многих часто возникает вопрос о том, как открыть бинарный файл. Этот документ представляет собой любой файл, который находится на персональном компьютере. Все данные, которые находятся на компьютерах и носителях, связанных с ним, записываются обычно в битах. Именно от этого слова и произошло название. Если в качестве сравнения привести простой текстовый файл, то проблем с его чтением не возникнет. Для этого достаточно иметь на компьютере обычный редактор, сойдет даже блокнот. Для того чтобы открыть бинарный файл, простым блокнотом обойтись не получится. И если говорить о том, что информация текстовых файлов зашифровывается все теми же битами, то обычно, когда говорят о чтении бинарных файлов, подразумевают исполняемые документы.

Инструкция к действию

Во-первых, на жесткий диск персонального компьютера необходимо установить программное средство под названием HexEditor, которое представляет собой простой редактор для бинарных файлов. После установки программу следует открыть, щелкнув для этого два раза кнопкой мыши по иконке. Это средство позволит проводить чтение бинарного файла в реальном режиме. При этом можно изменять данные в файле, добавлять свою информацию и т.д. Для того чтобы работать в данном редакторе и изменять бинарный файл, необходимо обладать хоть какими-нибудь знаниями в этой сфере деятельности.

Во-вторых, необходимо ознакомиться с Главное ее окно не имеет больших отличий от окна обычного редактора. Те же самые кнопки, то же меню, тело документа, закладки и строки состояния. Открыть интересующий файл можно через вкладку File или через специальную кнопку, которая располагается на в программе. После этого можно будет увидеть исполняемый файл, который предстанет в виде цифр и букв. Не стоит путать те символы, с помощью которых представлен бинарный файл, и те, которые имеет обычный редактор. В том случае, если будет принято решение об удалении или изменении какого-либо участка документа, следует понимать, что исчезнет или изменится какая-либо его часть.

В-третьих, с помощью программы можно попробовать изменить какой-либо участок документа. Как было сказано ранее, программное средство показывает файл в таком виде, который улучшает способы поиска необходимой части документа. К тому же программа обладает достаточно гибкой настройкой. С ее помощью можно изменить графическое отображение двоичного кода, который имеет бинарный файл. В том случае, если в какой-то участок файла будут внесены неправильные данные, то он впоследствии может либо полностью перестать работать, либо начнет работать не совсем корректно. В любом случае ввод таких данных вызовет изменения как в операционной системе, так и непосредственно в самом персональном компьютере.

В-четвертых, после изменения, удаления или добавления определенных данных в файле следует сохранить результат своей работы. В том случае, если достаточного опыта в редактировании файлов у вас нет, то следует быть готовым к не совсем приятным последствиям. Например, документ может перестать работать после изменения данных. До тех пор, пока вы не начнете хорошо разбираться в этом вопросе, будет испорчено очень много копий файлов. Если вы не уверены в своих возможностях, то изменять данные самостоятельно не стоит, особенно в тех ситуациях, когда исправить необходимо бинарный файл su.

записей ), то вполне понятно желание как-то сократить неиспользуемый, но занимаемый объем памяти.

Специально для таких случаев существуют записи с вариантной частью .

Описание записи с вариантной частью

В разделе var запись с вариантной частью описывают так:

var <имя_записи>: record <поле1>: <тип1>; [<поле2>: <тип2>;] [...] case <поле_переключатель>: <тип> of <варианты1>: (<поле3>: <тип3>; <поле4>: <тип4>; ...); <варианты2>: (<поле5>: <тип5>; <поле6>: <тип6>; ...); [...] end;

Невариантная часть записи (до ключевого слова case ) подчиняется тем же правилам, что и обычная запись . Вообще говоря, невариантная часть может и вовсе отсутствовать.

Вариантная часть начинается зарезервированным словом case , после которого указывается то поле записи , которое в дальнейшем будет служить переключателем. Как и в случае обычного оператора case , переключатель обязан принадлежать к одному из перечислимых типов данных (см. лекцию 3). Список вариантов может быть константой, диапазоном или объединением нескольких констант или диапазонов. Набор полей , которые должны быть включены в структуру записи , если выполнился соответствующий вариант, заключается в круглые скобки.

Пример . Для того чтобы описать содержимое библиотеки, необходима следующая информация:

Графы "Название" и "Издательство" являются общими для всех трех вариантов, а остальные поля зависят от типа печатного издания. Для реализации этой структуры воспользуемся записью с вариантной частью :

type biblio = record name,publisher: string; case item: char of "b": (author: string; year: 0..2004); "n": (data: date); "m": (year: 1700..2004; month: 1..12; number: integer); end;

В зависимости от значения поля item , в записи будет содержаться либо 4, либо 5, либо 6 полей .

Механизм использования записи с вариантной частью

Количество байтов, выделяемых компилятором под запись с вариантной частью , определяется самым "длинным" ее вариантом. Более "короткие" наборы полей из других вариантов занимают лишь некоторую часть выделяемой памяти.

В приведенном выше примере самым "длинным" является вариант " b ": для него требуется 23 байта (21 байт для строки и 2 байта для целого числа). Для вариантов " n " и " m " требуется 4 и 5 байт соответственно (см. таблицу).

name, publisher item Вариантная часть
... "b" author year
... "n" data
... "m" year month number
... "b" author year

Бинарные файлы

Бинарные файлы хранят информацию в том виде, в каком она представлена в памяти компьютера, и потому неудобны для человека. Заглянув в такой файл , невозможно понять, что в нем записано; его нельзя создавать или исправлять вручную - в каком-нибудь текстовом редакторе - и т.п. Однако все эти неудобства компенсируются скоростью работы с данными.

Кроме того, текстовые файлы относятся к структурам последовательного доступа , а бинарные - прямого. Это означает, что в любой момент времени можно обратиться к любому, а не только к текущему элементу

Работа с двоичными файлами

Вся информация хранится в компьютере в виде 0 и 1, т. е. в двоичном виде. Двоичные файлы отличаются от текстовых только методами работы с ними. Например, если мы записываем в текстовый файл цифру «4», то она записывается как символ, и для ее хранения нужен один байт. Соответственно и размер файла будет равен одному байту. Текстовый файл, содержащий запись: «145687», будет иметь размер шесть байт.

Если же записать целое число 145 687 в двоичный файл, то он будет иметь размер четыре байта, так как именно столько необходимо для хранения данных типа int. То есть двоичные файлы более компактны и в некоторых случаях более удобны для обработки.

Запись стандартных типов данных в двоичные файлы

Для того чтобы открыть двоичный файл, необходимо задать режим доступа ios::binary (в некоторых компиляторах C++ - ios::bin).

Для создания выходного файла создают объект:

ofstream outBinFile("out.bin", ios::out | ios::binary);

/* создание объекта класса ofstream out. bin

if (! out_f і 1) //стандартная проверка

Запись данных происходит с помощью метода write (), который имеет два параметра: первый - указатель на начало (адрес начала) записываемых данных, второй - количество записываемых байтов. При этом указатель необходимо явно преобразовать к типу char.

Пример 1. Записать в двоичный файл переменные различного типа:

ofstream outBinFile("test.bin", ios::out I

ios: :binary) ; /^создание объекта класса of stream и попытка связать его с файлом test. bin в режиме записи двоичного файла */

int а - 145687; //объявление целой переменной а

outBinFi le. write ((char*) &а, sizeof (а)) ; /^запись в файл

переменной а как потока байтов, т. е. запись в файл внутреннего представления целой переменной а */ float х - 123.25; // объявление вещественной переменной х

outBinFile .write ((char*) &х, sizeof (х)) ; /^запись в файл

переменной х как потока байтов, т. е. запись в файл внутреннего представления целой переменной х*/

//определение символьной переменной с и инициализация ее символом g outBinFile.write((char*)&c, sizeof(c));

//запись символа g в файл

outBinFile.close(); return 0;

Если открыть содержимое файла test .bin текстовым редактором, то он будет иметь вид:

а размер файла составит 9 байт.

Чтение стандартных типов данных из двоичных файлов

Для того чтобы открыть существующий двоичный файл для чтения, нужно создать объект:

ifstream inpBinFile("inp.bin", ios::in I ios::binary);

/* используем дизъюнкцию флагов, указывающую на то что файл открывается на чтение в двоичном виде*/

if (! inpBinFile)

coutДля чтения данных используем функцию read(), имеющую аналогичные функции write() параметры.

#include using namespace std; int main()

ifstream inpBinFile("test.bin", ios::in I

ios: : binary) ; //открываем файл на чтение в двоичном виде

int а; float х; char с = "g";

inpBinFile.read((char*)&a, sizeof(a));

//читаем целочисленную переменную inpBinFile.read((char*)&x, sizeof(x));

//читаем вещественную переменную inpBinFile.read((char*)&c, sizeof (c));

//читаем символьную переменную

inpBinFile.close(); cout

Результат работы программы:

а = 145687 х = 123.25 с = g

Обратите внимание, что при использовании функции write и read не происходит никакого преобразования информации. В файл записывается и считывается внутреннее представление данных. Именно поэтому две предыдущие программы дали правильный результат.

Запись и чтение пользовательских типов данных в двоичные файлы

В отличие от текстовых файлов, работа с пользовательскими типами данных с использованием двоичных файлов ничем не отличается от стандартных типов данных. Аналогично используются методы write() и read(). Программисту только остается указать адрес записываемого участка памяти и количество записываемых байтов, учтя при этом, что никакого преобразования данных не происходит, записывается и считывается только внутреннее представление информации.

Также при работе с двоичными файлами могут использоваться методы seekg(), tellg(), seekp(), tellp().

Пример 3. Написать программу, которая записывает сведения о группе туристов в двоичный файл.

fstream BinFile("ankety.bin", ios::in I ios::out | ios::binary);

Anketa Gruppa = ; for (int i = 0; i

BinFile.write((char*)&Gruppa[i], sizeof(Anketa)); BinFile.close(); return 0;

Пример 4. В файле «ankety.bin» содержатся данные о группе туристов, необходимо считать их и вывести на экран.

#include using namespace std; struct Anketa {

char name; int age;

структурного типа данных Anketa на экран*/

ostream& operator

fstream BinFile("ankety.bin", ios::in | ios::out | ios::binary); if (!BinFile)

for (int i = 0; i

//сразу читаем все байты, занимаемые переменной типа Anketa BinFile.read((char*)&Gruppa[i], sizeof(Anketa));

BinFile.close(); return 0;

Результат работы программы:

Ivanov, 23 Sidorov, 21 Petrov,22

Для продолжения нажмите любую клавишу. . .

Разработка собственных классов для работы с файлами

Постоянно пользоваться методами write() и read() неудобно, гораздо приятнее иметь возможность пользоваться операциями «>» по аналогии с текстовыми файлами. Приведем пример реализации своего класса для работы с двоичными файлами.

using namespace std;

struct Anketa //объявляем структуру для хранения информации

/*перегрузка операции вставки в поток для вывода пользовательского

структурного типа данных Anketa на экран*/

ostream& operator

class outBinaryFile: public of stream /^определяем свой класс для работы с выходными бинарными файлами. Порождаем его от класса работы с выходными файловыми потоками*/

/*при описании конструктора порожденного класса не забываем вызвать конструктор базового, передав ему необходимые параметры*/

outBinaryFile(char* name) : ofstream(name, ios::out I ios::binary)

//перегружаем необходимые операции как методы класса outBinaryFile& operator

write((char*)&chislo, sizeof(chislo)); return *this;

outBinaryFile& operator

write((char*)&ank, sizeof(ank)); return *this;

class inpBinaryFile: public if stream /* определяем свои класс для работы с входными бинарными файлами. Порождаем его от класса работы с входными файловыми потоками*/

inpBinaryFile(char* name) : ifstream(name, ios::in I ios::binary)

/*вызова конструктора базового класса с необходимыми параметрами,

достаточно для конструктора порожденного класса */

//перегружаем необходимые операции

inpBinaryFile& operator >> (int& chislo)

read((char*)&chislo, sizeof(chislo)); return *this;

inpBinaryFile& operator >> (Anketa& ank)

read((char*)&ank, sizeof(ank)); return *this;

int а = 111, b = 112; outBinaryFile outFile("dannye.bin");

//открываем файл на чтение

inpBinaryFile inpFile("dannye.bin"); if (!inpFile)

for (int і = 0; i

inpFile >> a; //читаем анкету из файла

cout //и выводим ее на экран

inpFile >> anketa; cout

Результат работы программы:

Kolya, 1990, 582-78-95.

Для продолжения нажмите любую клавишу. . .

1. Можно ли в программе использовать операцию?

ios::in I ios::out

  • а) да, в любом случае;
  • б) да, но только при работе с текстовыми файлами;
  • в) нет, в любом случае.
  • 2. Укажите правильный вариант открытия текстового файла для чтения:
    • а) ifstream inpF("input.txt", ios::in);
    • б) ifstream inpF("input.txt", ios::input);
    • в) ifstream inpF(ios:in, "input.txt").

З.Что будет выведено на экран в результате выполнения следующего кода?

inputFile.get(с);

next - inputFile.peek();

if (next == EOF)

  • а) содержимое файла, связанного с потоком inputFile, выведется на экран один раз;
  • б) содержимое файла, связанного с потоком inputFile, будет выводиться на экран бесконечное число раз;
  • в) на экран ничего не будет выведено.
  • 4. Сколько символов содержится в файле?
  • 12 3 4 5 6
  • а) 6;
  • б) 7;
  • в) 11.
  • 5. Какие методы позволяют определить конец файла?
  • а) eof();
  • б) good();
  • в) оба указанных метода.
  • 6. Для чего предназначена функция getline()?
  • а) считывает слово из файла;
  • б) считывает все содержимое файла;
  • в) считывает строку из файла.
  • 7. Чтобы записывать/считывать пользовательские типы данных в файл, необходимо:
    • а) перегрузить операции «>>» и «
    • б) запись и чтение пользовательских типов данных доступны без дополнительных действий;
    • в) запись и чтение пользовательских типов данных в файл невозможны.
  • 8. Какие функции используются для записи/чтения информации в двоичном виде?
  • а) printf / scanf;
  • б) write / read;
  • в) put / get.
  • 1. Написать программу, которая записывает в файл буквы английского алфавита.
  • 2. В файле input.txt записана информация из нескольких текстовых строк. Вывести содержимое этого файла на экран, посчитать количество строк в файле.
  • 3. На диске находится файл result.txt с результатами химических экспериментов. Написать программу, создающую копию этого файла с именем copy_resylt.txt.
  • 4. С клавиатуры ввести имя файла. В указанном файле удалить все четные строки.
  • 5. Написать программу, которая в текстовом файле, заменяет все строчные буквы прописными, и наоборот.
  • 6. В исходном текстовом файле находятся числа, разделенные пробелами. Сформировать два новых файла: первый должен содержать только четные числа, а второй - нечетные.
  • 7. В файл записаны вещественные числа. Написать программу, которая отбрасывает дробную часть у этих чисел и записывает их в новый файл.
  • 8. В текстовом файле записана информация о рейсах авиакомпании. Выбрать из этих данных рейсы, вылетающие после обеда, и вывести их на экран.
  • 9. Перегрузить операторы >> и
  • 10. Написать собственный класс для работы с бинарными файлами.
  • 11. Записать список 10 учеников класса в текстовый файл и в двоичный файл. Сравнить эти файлы. Объяснить полученное отличие.
  • 12. Разработать класс, который записывает в файл информацию об автомобилях (год выпуска, марку, цвет и т. д.) в текстовый файл. При этом каждый символ информации заменяется своим АБО 1-кодом. Полученный файл вывести на экран.

Контрольные вопросы

  • 1. Какие классы используются для работы с файловыми потоками?
  • 2. Какие режимы доступа могут использоваться при работе с файлами? Приведите примеры.
  • 3. Какой метод служит для открытия файла? Приведите примеры.
  • 4. Какие операции доступны для работы с файлами? Какие функции предназначены для выполнения этих операций?
  • 5. Какие методы позволяют определить конец файла при чтении из него информации? В чем отличие этих методов? Приведите примеры.
  • 6. Каким образом можно считать переменные стандартных типов данных из текстовых файлов?
  • 7. Можно ли считывать из текстовых файлов переменные пользовательских типов данных?
  • 8. Какие функции предназначены для произвольного чтения информации из файла? Приведите примеры.
  • 9. Назовите особенности двоичных файлов. В чем преимущества использования таких файлов?
  • 10. С помощью каких функций можно записывать/считывать информацию в двоичные файлы?
  • 11. Как считать переменные стандартных типов данных из двоичного файла?
  • 12. Какие особенности нужно учитывать при чтении пользовательских типов данных из двоичных файлов?
  • "Ivanov", 23}, {"Sidorov", 21},