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

Двоичные файлы с числовой информацией: File48

Особенности выполнения заданий на обработку файлов рассмотрим на примере задания File48.

File48°. Даны три файла целых чисел одинакового размера с именами S_A, S_B, S_C и строка S_D. Создать новый файл с именем S_D, в котором чередовались бы элементы исходных файлов с одним и тем же номером: A₁, B₁, C₁, A₂, B₂, C₂, ... .

Создание программы-заготовки и знакомство с заданием

Напомним, что проект-заготовку для решения задания можно создать с помощью модуля PT4Load. Приведем текст функции Solve из файла File48.cpp, входящего в созданный проект (именно в эту функцию требуется ввести решение задания):

void Solve()
{
  Task("File48");
}

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

В первой строке раздела исходных данных указаны имена трех исходных файлов (S_A, S_B и S_C) и одного результирующего (S_D). В трех последних строках раздела исходных данных показано содержимое исходных файлов. Для отображения содержимого каждого файла отводится по одной строке. Элементы файлов отображаются бирюзовым цветом, чтобы подчеркнуть их отличие от обычных исходных данных (желтого цвета) и комментариев (светло-серого цвета).

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

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

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

Ввод исходных данных

При выполнении заданий, связанных с обработкой файлов, будем использовать файловые потоки ввода-вывода, реализованные в стандартной библиотеке ввода-вывода C++, не применяя стандартные функции ввода-вывода языка C (такие, например, как fopen и printf).

Добавим в файл File48.cpp перед описанием функции Solve директиву, подключающую стандартную библиотеку для работы с файловыми потоками:

#include <fstream>

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

void Solve()
{
  Task("File48");
  fstream* f = new fstream[4];
  int i;
  for (i = 0; i < 3; i++)
  {
    string s;
    pt >> s;
    f[i].open(s.c_str(), ios_base::binary | ios_base::in);
  }
  delete[] f;
}

Мы намеренно ограничились тремя итерациями цикла, оставив непрочитанным имя результирующего файла. Считывание имен файлов производится в одну и ту же переменную s, поскольку после связывания файла, имеющего имя s, с файловым потоком f[i] все остальные действия с данным файлом в нашей программе будут осуществляться с использованием потока f[i], без обращения к имени файла.

Для ввода имени файла использовалась переменная типа string. Поскольку в методе open первый параметр (имя файла) должен иметь тип char*, был использован метод c_str, преобразующий содержимое строки к типу char*.

Запуск нового варианта программы уже не будет считаться ознакомительным, поскольку в программе выполняется ввод исходных данных. Так как имя результирующего файла осталось непрочитанным, этот вариант решения будет признан неверным и приведет к сообщению «Введены не все требуемые исходные данные. Количество прочитанных данных: 3 (из 4)».

Изменим функцию Solve, заменив в заголовке цикла число 3 на 4, и вновь запустим программу. Теперь все данные, необходимые для выполнения задания, в программу введены. Однако задание не выполнено, поскольку результирующий файл не создан. Поэтому решение опять признано ошибочным с диагностикой «Результирующий файл не найден».

Отметим, что при выполнении последней, четвертой, итерации цикла попытка открыть файл приведет к ошибке времени выполнения, поскольку для этого файла, как и для всех предыдущих, указан режим открытия для чтения (ios_base::in), в то время как файл с указанным именем не существует. Однако подобные ошибки в языке C++ не приводят к аварийному завершению программы.

Примечания. 1) Массив файловых потоков можно было бы описать следующим образом:

  fstream f[4];

В этом случае в конце программы не нужно указывать оператор delete[] f. Следует, однако, отметить, что компиляция указанного варианта описания массива f в среде C++Builder приводит к сообщению об ошибке (в средах Visual C++ и Visual Studio ошибки не возникает).

2) Имена файлов можно было бы вводить в переменную типа char* или char[N], если размер N строки заранее известен, например:

  char s[13];

В этом случае в качестве первого параметра метода open можно указать саму переменную s. Размер массива символов s выбран таким образом, чтобы в массиве можно было сохранить имя файла в стандартном формате «8.3» (собственно имя файла длины не более 8 символов, точка и расширение длины не более 3 символов). Учтено также, что любая C-строка должна быть дополнена нулевым символом. Примеры использования типа char[13] для хранения имен файлов будут приведены в следующем разделе, посвященном строковым и текстовым файлам.

Создание пустого результирующего файла

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

void Solve()
{
  Task("File48");
  fstream *f = new fstream[4];
  int i;
  for (i = 0; i < 4; i++)
  {
    string s;
    pt >> s;
    if (i < 3)
      f[i].open(s.c_str(), ios_base::binary | ios_base::in);
    else
      f[i].open(s.c_str(), ios_base::binary | ios_base::out);
  }
  /* */
  for (i = 0; i < 4; i++)
    f[i].close();
  delete[] f;
}

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

При выполнении этого варианта программы результирующий файл будет создан. Однако созданный файл останется пустым, т. е. не содержащим ни одного элемента. Поэтому после запуска программы на информационной панели появится сообщение «Ошибочное решение», а в строке, которая должна содержать элементы результирующего файла, появится текст

EOF:

Особое значение EOF (End Of File — «конец файла») для указателя текущей файловой позиции в окне задачника означает, что данный файл существует, но не содержит ни одного элемента. Таким образом, нам осталось реализовать фрагмент алгоритма, обеспечивающий ввод и вывод файловых данных.

Использование неправильных типов для файловых элементов

Во всех ранее рассмотренных вариантах программы мы не использовали операции ввода-вывода для файлов. Поэтому тип файловых элементов нас не интересовал.

Однако при чтении данных из файла (и при их записи в файл) крайне важно правильно указывать тип файловых элементов. Чтобы продемонстрировать это на примере нашей программы, попытаемся прочесть из исходных файлов по одному элементу вещественного типа и запишем прочитанные элементы в файл результатов. Для этого заменим комментарий /* */ на следующий фрагмент:

for (i = 0; i < 3; i++)
{
  double x;
  f[i].read((char *)&x, sizeof(x));
  f[3].write((char *)&x, sizeof(x));
}

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

Результат работы программы будет неожиданным: судя по экранной строке с содержимым результирующего файла, в него будут записаны не три, а шесть элементов, по два начальных элемента из каждого исходного файла. Объясняется это тем, что считывание из файла и последующая запись в файл одного «вещественного элемента» фактически приводит к считыванию и записи блока данных размером 8 байтов, содержащего два последовательных целочисленных элемента исходного файла.

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

Для исправления данной ошибки достаточно изменить описание переменной x:

  int x;

Запустив исправленную программу, мы получим все еще неверный, но вполне «понятный» результат: созданный файл будет содержать три элемента, совпадающих с начальными элементами исходных файлов.

Правильное решение, его тестирование и просмотр результатов

Приведем, наконец, верное решение задания File48:

void Solve()
{
  Task("File48");
  fstream *f = new fstream[4];
  int i;
  for (i = 0; i < 4; i++)
  {
    string s;
    pt >> s;
    if (i < 3)
      f[i].open(s.c_str(), ios_base::binary | ios_base::in);
    else
      f[i].open(s.c_str(), ios_base::binary | ios_base::out);
  }
  while (f[0].peek() != -1)
    for (i = 0; i < 3; i++)
    {
      int x;
      f[i].read((char *)&x, sizeof(x));
      f[3].write((char *)&x, sizeof(x));
    }
  for (i = 0; i < 4; i++)
    f[i].close();
  delete[] f;
}

От предыдущего варианта данное решение отличается добавлением цикла while (f[0].peek() != –1), который обеспечивает считывание всех элементов из исходных файлов (напомним, что по условию задания все исходные файлы имеют одинаковый размер) и запись их в результирующий файл в нужном порядке. В условии цикла while использован метод peek(), который возвращает код очередного символа из файла, не считывая данный символ (и, следовательно, не перемещая файловый указатель), причем если достигнут конец файла, то данный метод возвращает –1.

После запуска этого варианта мы получим сообщение «Верное решение. Тест номер 1 (из 5)», а после пяти подобных запусков — сообщение «Задание выполнено!». С помощью команды меню Visual Studio «Tools | PT4 Results» мы можем вывести на экран окно результатов, в котором будут перечислены все наши попытки решения задания:

File48     c24/03 12:15 Ознакомительный запуск.
File48     c24/03 12:16 Введены не все требуемые исходные данные.
File48     c24/03 12:17 Результирующий файл не найден.
File48     c24/03 12:19 Ошибочное решение.--3
File48     c24/03 12:21 Задание выполнено!

Строковые и текстовые файлы: File67, Text21

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

Двоичные строковые файлы

В качестве примера задания на строковые файлы рассмотрим задание File67.

File67°. Дан строковый файл, содержащий даты в формате «день/месяц/год», причем под день и месяц отводится по две позиции, а под год — четыре (например, «16/04/2001»). Создать два файла целых чисел, первый из которых содержит значения дней, а второй — значения месяцев для дат из исходного строкового файла (в том же порядке).

При выполнении заданий на языке C++ предполагается, что элементы в строковом файле всегда занимают 80 байтов, независимо от длины содержащейся в нем строки (фактическая длина строки определяется по положению завершающего ее нулевого символа '\0'). Поэтому для операций ввода-вывода, связанных со строковыми файлами, необходимо использовать переменные типа char[80]. При открытии строковых файлов, как и при открытии других двоичных файлов, необходимо указывать атрибут ios_base::binary. Для чтения строк из строкового файла, как и для чтения данных из двоичных файлов других типов, следует использовать метод read.

Сразу приведем правильное решение задания File67, учитывающее отмеченные выше особенности строковых файлов (в данном решении используются файловые потоки типов ifstream и ofstream, первый из которых открывает файл только на чтение, а второй — только на запись):

#include <fstream>
void Solve()
{
  Task("File67");
  ifstream f;
  ofstream f1, f2;
  char s[13], s1[13], s2[13], x[80], a[3];
  pt >> s >> s1 >> s2;
  f.open(s, ios_base::binary);
  f1.open(s1, ios_base::binary);
  f2.open(s2, ios_base::binary);
  while (f.peek() != -1)
  {
    f.read((char *)&x, sizeof(x));
    strncpy(a, x, 2);
    int n = atoi(a);
    f1.write((char *)&n, sizeof(n));
    strncpy(a, &x[3], 2);
    n = atoi(a);
    f2.write((char *)&n, sizeof(n));
  }
  f.close();
  f1.close();
  f2.close();
}

Текстовые файлы

В качестве примера задания на текстовые файлы рассмотрим задание Text21.

Text21°. Дан текстовый файл, содержащий более трех строк. Удалить из него последние три строки.

Поскольку текстовые файлы, в отличие от двоичных файлов, нельзя открыть одновременно на чтение и на запись, для изменения текстового файла необходимо воспользоваться вспомогательным файлом. Во вспомогательный файл записываются необходимые результирующие данные, после чего исходный файл удаляется с диска, а имя вспомогательного файла заменяется на имя исходного. Далее, поскольку строки, содержащиеся в текстовом файле, могут иметь различную длину, для определения числа строк необходимо последовательно считать из файла все его строки. Заметим, что для чтения данных из текстовых файлов следует использовать не метод read (как для двоичных строковых файлов), а метод getline. При выполнении заданий можно считать, что длина любой строки в текстовом файле не превосходит 79 символов.

Приведем решение задания Text21, учитывающее отмеченные выше особенности текстовых файлов:

#include <fstream>
void Solve()
{
  Task("Text21");
  ifstream f1;
  ofstream f2;
  char s[80], s1[13], s2[10] = "$T21$.tmp";
  int n = 0;
  pt >> s1;
  f1.open(s1);
  f2.open(s2);
  while (f1.peek() != -1)
  {
    f1.getline(s, 80);
    n++;
  }
  f1.clear();
  f1.seekg(0);
  for (int i = 0; i < n - 3; i++)
  {
    f1.getline(s, 80);
    f2 << s << endl;
  }
  f1.close();
  f2.close();
  remove(s1);
  rename(s2, s1);
}

Обратите внимание на вызов метода f1.clear(), возвращающий поток ввода-вывода из состояния «достигнут конец файла» или из состояния ошибки в стандартное состояние: если не вызвать данный метод, то все последующие попытки чтения из потока будут оканчиваться неудачей (и в результате полученный файл будет содержать лишь пустые строки).

Приведенный выше вариант решения является неэффективным, поскольку требует двух просмотров исходного файла f1: первый — для определения его размера, который записывается в переменную n, второй — для создания вспомогательного файла f2, содержащего все строки исходного файла, кроме трех последних.

Задание Text21 можно выполнить и за один просмотр исходного файла, если воспользоваться следующим наблюдением: строка должна быть записана во вспомогательный файл, если после нее в исходном файле находятся по крайней мере три строки. Таким образом, записывать очередную строку во вспомогательный файл следует только после считывания из исходного файла трех следующих за ней строк. Благодаря такому упреждающему считыванию необходимость в предварительном определении размера исходного файла отпадает. Для хранения строк, которые уже считаны из исходного файла, но еще не записаны во вспомогательный файл, удобно использовать массив из трех элементов типа char[80].

Приведем программу, реализующую описанный выше эффективный однопроходный алгоритм решения задания:

#include <fstream>
void Solve()
{
  Task("Text21");
  ifstream f1;
  ofstream f2;
  char s[3][80], s1[13], s2[10] = "$T21$.tmp";
  pt >> s1;
  f1.open(s1);
  f2.open(s2);
  for (int i = 0; i < 3; i++)
    f1.getline(s[i], 80);
  int n = 0;
  while (f1.peek() != -1)
  {
    f2 << s[n] << endl;
    f1.getline(s[n], 80);
    n = (n + 1) % 3;
  }
  f1.close();
  f2.close();
  remove(s1);
  rename(s2, s1);
}

Разработка сайта:
М. Э. Абрамян, В. Н. Брагилевский

Последнее обновление:
11.10.2011