Programming Taskbook


E-mail:

Пароль:

Регистрация пользователя   Восстановление пароля

English

ЮФУ

Электронный задачник по программированию

©  М. Э. Абрамян (Южный федеральный университет), 1998–2018

 

Решения | C++ | Обработка файлов

PrevNext


Выполнение заданий на обработку файлов

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

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

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

File48°. Даны три файла целых чисел одинакового размера с именами SA, SB, SC и строка SD. Создать новый файл с именем SD, в котором чередовались бы элементы исходных файлов с одним и тем же номером: A1B1C1, A2B2C2, ... .

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

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

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

После запуска программы на экране появится окно задачника. На рисунке приведены два варианта представления окна — в режиме с динамической и с фиксированной компоновкой:


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

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

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

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

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

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

При выполнении заданий, связанных с обработкой файлов, будем использовать файловые потоки ввода-вывода, реализованные в стандартной библиотеке ввода-вывода 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, преобразующий содержимое строки к типу const char*.

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

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

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

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

  fstream f[4];

В этом случае в конце программы не нужно указывать оператор delete[] f.

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.

При выполнении этого варианта программы результирующий файл будет создан, однако останется пустым, т. е. не содержащим ни одного элемента. Начиная с версии 4.15, в этом случае на информационной панели выводится сообщение (на светло-синем фоне): «Запуск с правильным вводом данных: все требуемые данные введены, результирующий файл является пустым» (в предыдущих версиях в этой ситуации на информационной панели выводилось сообщение «Ошибочное решение», а в строке, которая должна содержать элементы результирующего файла, отображался текст 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.

После запуска этого варианта программы и успешного прохождения 5 тестов мы получим сообщение «Задание выполнено!». Нажав клавишу [F2], мы можем вывести на экран окно результатов, в котором будут перечислены все наши попытки решения задачи:

File48     c24/03 12:15 Ознакомительный запуск.
File48     c24/03 12:16 Введены не все требуемые исходные данные.
File48     c24/03 12:17 Запуск с правильным вводом данных.--2
File48     c24/03 12:19 Ошибочное решение.--2
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);
}

PrevNext

 

Рейтинг@Mail.ru

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

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