C++. Примеры работы с текстовыми файлами. Модификация файлов. Сортировка данных в файлах. Конвертирование данных файла в список

Примеры работы с текстовыми файлами. Модификация файлов. Сортировка данных в файлах. Конвертирование данных файла в массив

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


Содержание


Поиск на других ресурсах:




1. Как определить, что данные в текстовом файле закончились?

Для определения конца файла используется функция eof(). Функция возвращает результат типа bool. Прототип функции следующий

bool std::eof();

здесь std – пространство имен, в котором объявлена функция eof().

Если при вызове функции текущий указатель чтения указывает на конец файла, то функция возвращает true. В противном случае функция возвращает false.

Пример 1.

Ниже приведен фрагмент кода, в котором используется функция eof() для определения, достигнут ли конец файла, которому соответствует экземпляр с именем inputFile

if (inputFile.eof() == false)
{
  cout << "End of file not reached.";
}
else
{
  cout << "End of file is reached.";
}

Пример 2.

Чаще всего функция eof() используется в цикле while при чтении строк файла

while (!inputFile.eof()) // пока не конец файла
{
  // Считывание строк из файла
  // ...
}

Как только будет достигнут конец файла inputFile, то произойдет выход из цикла.

 

2. Функция CountLinesInFile(). Подсчет количества строк в текстовом файле

Функция CountLinesInFile() возвращает количество строк в текстовом файле.

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция, определяющая количество строк в файле.
// Имя файла задается входным параметром
int CountLinesInFile(char* filename)
{
  // 1. Объявить экземпляр F, который связан с файлом filename.
  // Файл открывается для чтения в текстовом формате.
  ifstream F(filename, ios::in);

  // 2. Проверка, существует ли файл
  if (!F)
  {
    return -1;
  }

  // 3. Вычислить количество строк в файле
  // 3.1. Объявить дополнительные переменные
  int count = 0;
  char buffer[1000]; // буфер для сохранения одной строки

  // 3.2. Цикл чтения строк.
  // Каждая строка файла читается функцией getline().
  // Проверка конца файла осуществляется функцией eof().
  while (!F.eof())
  {
    // Увеличить счетчик строк
    count++;

    // Считать одну строку в буфер
    F.getline(buffer, 1000);
  }

  // 4. Закрыть файл F
  F.close();

  // 5. Вернуть результат
  return count;
}

void main()
{
  // Определение количества строк в файле "TextFile1.txt"
  int nLines = CountLinesInFile((char*)"TextFile1.txt");

  // Вывод результата
  if (nLines == -1)
    cout << "Error opening file";
  else
    cout << "nLines = " << nLines << endl;
}

 

3. Функция GetStringsFromFileC(). Получить массив (список) строк типа char* из текстового файла

Список строк можно вернуть одним из двух способов, в которых одна строка воспринимается по разному:

  • как тип char*. В этом случае список строк имеет тип char**;
  • как тип string – список строк имеет тип string*.

Для определения количества строк в файле функция обращается к функции CountLinesInFile(), которая описывается в пункте 2.

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция, которая возвращает строки файла в виде списка типа char**.
// Параметры:
// - filename - имя файла;
// - _lines - список строк файла типа (char**).
// Функция возвращает общее количество прочитанных строк в файле,
// если чтение произошло неудачно, то функция возвращает -1.
int GetStringsFromFileC(string filename, char*** _lines = nullptr)
{
  // 1. Дополнительные переменные
  char** lines;
  int n = CountLinesInFile(filename); // получить количество строк в файле

  // 2. Проверка, известно ли количество строк
  if (n == -1) return -1;

  // 3. Объявить файловую переменную
  ifstream F(filename); // открыть файл для чтения

  // 4. Проверка, открылся ли файл
  if (!F) return -1;

  // 5. Попытка выделить память для n строк
  try
  {
    lines = new char* [n];
  }
  catch (bad_alloc e)
  {
    // если невозможно выделить память, то выход
    cout << e.what() << endl; // вывести сообщение об ошибке
    F.close(); // закрыть файл
    return -1;
  }

  // 6. Цикл чтения строк и выделения памяти для них
  int len; // длина одной строки
  char buffer[1000]; // память, куда записывается одна строка из файла

  for (int i = 0; i < n; i++)
  {
    // 6.1. Считать строку из файла
    F.getline(buffer, 1000);

    // 6.2. Определить длину прочитанной строки
    for (len = 0; buffer[len] != '\0'; len++);

    // 6.3. Выделить память для len+1 символов
    lines[i] = new char[len + 1];

    // 6.4. Скопировать данные из buffer в lines[i]
    for (int j = 0; j < len; j++)
      lines[i][j] = buffer[j];
    lines[i][len] = '\0'; // добавить символ конца строки
  }

  // 7. Закрыть файл
  F.close();

  // 8. Записать результат
  *_lines = lines;
  return n;
}

Использование функции GetStringsFromFileC() может быть, например, следующим:

void main()
{
  // Вывод списка строк файла на екран
  // 1. Объявить внутренние переменные
  int count; // количество строк
  char** lines = nullptr; // список строк типа char*

  // 2. Получить список строк типа char**
  count = GetStringsFromFileC("TextFile1.txt", &lines);

  // 3. Проверка, получен ли список
  if (count < 0)
  {
    cout << "Error" << endl;
    return;
  }

  // 3. Вывести список строк на экран
  for (int i = 0; i < count; i++)
  {
    cout << lines[i] << endl;
  }

  // 4. Освободить память, выделенную для каждой строки lines
  if (lines!=nullptr)
    for (int i = 0; i < count; i++)
      delete lines[i];

  // 5. Освободить память, выделенную для массива lines
  if (lines != nullptr)
    delete[] lines;
}

 

4. Функция GetStringsFromFileS(). Получить массив строк типа string из текстового файла

Работа с типом string более удобна чем с типом char*. В следующем фрагменте кода реализована функция GetStringsFromFileS(), читающая строки из текстового файла и записывающая их в массив (список) типа string. Данная функция использует функцию CountLinesInFile(), которая описывается в пункте 2 данной темы.

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция, получающая строки файла в виде списка типа string*
// Параметры:
// - filename - имя файла;
// - _lines - список строк файла типа (string*).
// Функция возвращает общее количество прочитанных строк.
int GetStringsFromFileS(string filename, string** _lines)
{
  // 1. Дополнительные переменные
  string* lines; // временный список строк
  int n = CountLinesInFile(filename); // Получить количество строк в файле

  // 2. Проверка, правильно ли прочитаны строки из файла
  if (n == -1) return -1;

  // 3. Объявить файловую переменную и открыть файл filename для чтения
  ifstream F(filename);

  // 4. Проверка, открыт ли файл
  if (!F) return -1;

  // 5. Попытка выделить память для n строк типа string
  try
  {
    lines = new string[n];
  }
  catch (bad_alloc e)
  {
    cout << e.what() << endl; // вывести сообщение об ошибке
    F.close();
    return -2; // возврат с кодом -2
  }

  // 6. Чтение строк из файла и запись строк в список lines
  char buffer[1000]; // буфер для чтения строки

  for (int i = 0; i < n; i++)
  {
    // 6.1. Прочитать строку из файла в буфер buffer
    F.getline(buffer, 1000);

    // 6.2. Вычислить длину прочитанной строки
    int len;
    for (len = 0; buffer[len] != '\0'; len++);

    // 6.3. Записать buffer => lines[i], использовать метод assign().
    // Скопировать len байт из buffer в lines[i].
    lines[i].assign(buffer, len);
  }

  // 7. Закрыть файл
  F.close();

  // 8. Вернуть результат
  *_lines = lines;
  return n;
}

Использование функции GetStringsFromFileS() может быть, например, следующим

void main()
{
  // Вывод списка строк файла на экран
  // 1. Объявить внутренние переменные
  int count; // количество строк
  string* lines = nullptr; // список строк типа string

  // 2. Получить список строк типа string*
  count = GetStringsFromFileS("TextFile1.txt", &lines);

  // 3. Проверка, получен ли список
  if (count < 0)
  {
    cout << "Error" << endl;
    return;
  }

  // 3. Вывести список строк на экран
  for (int i = 0; i < count; i++)
  {
    cout << lines[i] << endl;
  }

  // 4. Освободить память, выделенную для массива lines
  if (lines != nullptr)
    delete[] lines;
}

Результат работы программы (содержимое файла TextFile1.txt):

#include <iostream>

using namespace std;

void main()
{
  cout << "Hello world!";
}

 

5. Функция SetStringsToFileS(). Записать массив (список) строк типа string в текстовый файл

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

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция, которая записывает массив строк типа string в текстовый файл.
// Параметры:
// - filename - имя файла;
// - lines - массив строк, которые записываются в файл;
// - count - количество строк.
// Функция возвращает true, если запись строк произошла успешно.
bool SetStringsToFileS(string filename, string* lines, int count)
{
  // 1. Объявить дополнительные переменные
  ofstream F(filename); // открыть файл для записи

  // 2. Проверка, успешно ли открылся файл
  if (!F) return false;

  // 3. Запись строк в файл кроме последней строки
  for (int i = 0; i < count - 1; i++)
    F << lines[i] << endl;

  // 4. Последнюю строку записать как есть (без символа '\n')
  F << lines[count - 1];

  // 5. Закрыть файл
  F.close();

  // 6. Вернуть результат
  return true;
}

Ниже приведен пример использования функции SetStringsToFileS().

void main()
{
  // Запись массива строк в файл
  // 1. Объявить внутренние переменные
  int count; // количество строк
  string* lines = nullptr; // список строк типа string

  // 2. Сформировать строки
  try
  {
    // попытка выделить память для 5 строк
    lines = new string[5];
  }
  catch (bad_alloc e)
  {
    cout << e.what() << endl;
    return;
  }

  // записать в строки некоторый текст
  lines[0] = "#include <stdio.h>";
  lines[1] = "using namespace std";
  lines[2] = "void main()";
  lines[3] = "{";
  lines[4] = "}";

  // 3. Записать строки в файл TextFile2.txt
  if (SetStringsToFileS("TextFile2.txt", lines, 5))
    cout << "OK!" << endl;
  else
    cout << "Error." << endl;

  // 4. Освободить память, выделенную для массива lines
  if (lines != nullptr)
    delete[] lines;
}

 

6. Функция ChangeStringInFileC(). Замена строки в текстовом файле

В примере приведена функция, заменяющая строку в файле в заданной позиции. Данная функция использует следующие функции:

  • CountLinesInFile() — определяет количество строк в файле (реализована в п. 3);
  • GetStringsFromFileC() — возвращает строки файла в виде массива (реализована в п. 4). Строки представлены типом char*.

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

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция, заменяющая строку в файле.
// Параметры:
// - filename - имя файла;
// - position - позиция строки в файле, которую нужно заменить;
// - str - строка, заменяющая строку в файле.
// Функция возвращает true, если операция замены строки прошла успешно.
bool ChangeStringInFileC(string filename, int position, string str)
{
  // 1. Получить строки файла в виде списка
  char** lines; // список строк файла
  int count; // количество строк файла
  count = GetStringsFromFileC(filename, &lines); // получить список lines

  // 2. Проверка, корректно ли прочитан файл
  if (count < 0) return false;

  // 3. Проверка, корректна ли позиция 0 <= position < count
  if ((position < 0) || (position >= count)) return false;

  // 4. Запись строк lines в файл до позиции position
  ofstream F(filename); // открыть файл для записи

  // 5. Проверка, открылся ли файл корректно - функция is_open()
  if (!F.is_open()) return false;

  for (int i = 0; i < position; i++)
    F << lines[i] << endl; // вывести строку в файл

  // 6. Запись строки с позиции position
  F << str.c_str() << endl; // здесь пишется строка str

  // 7. Запись строк после позиции position
  for (int i = position + 1; i < count - 1; i++)
    F << lines[i] << endl;

  // 8. Записать последнюю строку без символа '\n'
  F << lines[count - 1];

  // 9. Закрыть файл
  F.close();

  // 10. Освободить память, выделенную для строк
  for (int i = 0; i < count; i++)
    delete lines[i];

  // 11. Освободить указатели на строки
  delete[] lines;
}

Использование данной функции може быть, например, следующим:

void main()
{
  // Замена входной строки в файле
  string filename = "TextFile1.txt"; // исходный файл
  int pos = 5; // исходная позиция строки
  string str = "Hello world!"; // Исходная строка замены

  if (ChangeStringInFileC(filename, pos, str))
  {
    cout << "OK!!!";
  }
  else
  {
    cout << "Error";
  }
}

По желанию, можно изменить ввод входных данных (имя файла, позиция, строка замены).

 

7. Функция RemoveStringFromFileByIndex(). Удаление строки из файла по его номеру

Удаление строки из файла по его номеру можно выполнять по примеру п. 6 (замена строки в текстовом файле).
Общий алгоритм следующий:

  • прочитать все строки файла в массив (список);
  • удалить строку из массива;
  • записать модифицированный массив обратно в файл.

Для формирования списка строк можно использовать функции GetStringsFromFileC() и GetStringsFromFileS(), которые описаны в пунктах 3 и 4.

Текст функции удаления строки по его номеру следующий.

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция, удаляющая строку в файле по заданному номеру,
// номер строки начинается с 0.
// Параметры функции:
// - filename - имя файла, из которого удаляется строка;
// - position - номер строки в файле, которую нужно удалить.
// Если операция прошла успешно, функция возвращает true, если
// строка не удалена, функция возвращает false.
bool RemoveStringFromFileByIndex(string filename, int position)
{
  // 1. Проверка, правильно ли указана строка
  if (position < 0) return false;

  // 2. Дополнительные переменные
  string* lines; // список строк
  int n; // количество строк в списке (файле)

  // 3. Прочитать количество строк в файле
  n = CountLinesInFile(filename); // вызов функции из пункта 2

  // 4. Проверка, прочитался ли файл filename
  if (n == -1) return false;

  // 5. Проверка, корректно ли значение position
  if (position >= n) return false;

  // 6. Получить список строк lines типа string*
  n = GetStringsFromFileS(filename, &lines); // функция из пункта 4

  // 7. Удалить строку в позиции position
  for (int i = position; i < n - 1; i++)
    lines[i] = lines[i + 1];

  // 8. Уменьшить общее количество строк
  n--;

  // 9. Записать список в файл - использовать функцию SetStringsToFileS()
  bool res = SetStringsToFileS(filename, lines, n); // запись списка

  // 10. Освободить массив lines
  if (n > 0) delete[] lines;

  // 11. Вернуть результат
  return res;
}

Использование функции может быть, например, следующим

void main()
{
  // Удаление исходной строки в файле
  string filename = "TextFile1.txt"; // исходный файл
  int pos = 7; // указанная позиция строки

  if (RemoveStringFromFileByIndex(filename,pos))
  {
    cout << "OK!!!";
  }
  else
  {
    cout << "Error";
  }
}

 

8. Функция InsertStringToFile(). Вставка строки в заданную позицию в файле

Подход такой же, как в предыдущих пунктах. Нужно получить строки файла в виде массива (тип string или char*). Затем нужно вставить строку в массив и записать измененный массив строк обратно в файл.
Если значение позиции вставки равно количеству элементов в файле, то строка добавляется в конец файла.

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция, которая вставляет указанную строку в указанною позицию файла.
// Параметры функции:
// - filename - імя файла;
// - str - строка, которая вставляется;
// - position - позиция строки str. Нумеруется с 0 до количества строк в файле.
// Если вставка произошла успешно, функция возвращает true.
bool InsertStringToFile(string filename, string str, int position)
{
  // 1. Объявить дополнительные переменные
  int count;
  string* lines = nullptr; // список строк файла

  // 2. Получить список строк из файла - вызов функции, описанной в п.4
  count = GetStringsFromFileS(filename, &lines);

  // 3. Проверка, происходит ли нормально процесс чтения строк
  if ((count < 0)) return false;

  // 4. Проверка, корректно ли значение position.
  // Если positon==count, то строка добавляется в конец файла.
  if ((position < 0) || (position > count)) return false;

  // 5. Создать новый список lines2, в котором на 1 элемент больше
  string* lines2 = nullptr;
  try
  {
    // попытка выделить память для массива lines2
    lines2 = new string[count + 1];
  }
  catch (bad_alloc e)
  {
    // если попытка выделения памяти неудачна, то завершить программу
    cout << e.what() << endl;
    if (lines != nullptr) // освободить память
      delete[] lines;
    return false;
  }

  // 6. Скопировать lines=>lines2
  // 6.1. Сначала скопировать до позиции position
  for (int i = 0; i < position; i++)
    lines2[i] = lines[i];

  // 6.2. Добавить к lines2[position] строку str
  lines2[position] = str;

  // 6.3. Скопировать следующие строки
  for (int i = position; i < count; i++)
    lines2[i + 1] = lines[i];

  // 7. Увеличить общее количество строк на 1
  count++;

  // 8. Записать строки lines в файл
  bool res = SetStringsToFileS(filename, lines2, count);

  // 9. Освободить память, выделенную для строк lines, lines2
  if (lines != nullptr) delete[] lines;
  if (lines2 != nullptr) delete[] lines2;

  // 10. Вернуть результат
  return res;
}

Вызов функции InsertStringToFile() в функции main() может быть следующим.

void main()
{
  // Вставка указанной строки в заданную позицию файла
  string filename = "TextFile1.txt"; // исходный файл
  int pos = 8; // указанная позиция строки
  string s = "Hello"; // строка вставки

  if (InsertStringToFile(filename, s, pos))
  {
    cout << "OK!!!";
  }
  else
  {
    cout << "Error";
  }
}

 

9. Функция SwapStringsInFile(). Обмен местами двух строк в файле

Сокращенный алгоритм функции SwapStringsInFile() следующий:

  1. Прочитать строки файла в список.
  2. Поменять строки в списке.
  3. Записать измененный список обратно в файл.

Текст функции обмена строк следующий.

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция, которая меняет местами две строки в указанных позициях.
// Параметры:
// - filename - имя файла;
// - pos1 - позиция строки обмена 1 (нумеруется с 0);
// - pos2 - позиция строки обмена 2 (нумеруется с 0).
// Если обмен прошел успешно, то функция возвращает true. Иначе false.
bool SwapStringsInFile(string filename, int pos1, int pos2)
{
  // 1. Проверка, корректны ли значения pos1, pos2
  if ((pos1 < 0) || (pos2 < 0)) return false;

  // 2. Объявить дополнительные переменные
  int count;
  string* lines = nullptr; // массив строк файла
  string s;

  // 3. Получить массив строк файла
  count = GetStringsFromFileS(filename, &lines); // функция из п.4

  // 4. Проверка, произошло ли успешно чтение из файла
  if (count < 0) return false;

  // 5. Проверка, лежат ли значения pos1, pos2 в пределах count
  if (pos1 >= count) return false;
  if (pos2 >= count) return false;

  // 6. Поменять местами строки lines[pos1] и lines[pos2]
  s = lines[pos1];
  lines[pos1] = lines[pos2];
  lines[pos2] = s;

  // 7. Записать массив lines обратно в файл
  bool res = SetStringsToFileS(filename, lines, count);

  // 8. Освободить память, выделенную для массива lines
  if (lines != nullptr)
    delete[] lines;

  // 9. Вернуть результат
  return res;
}

Вызов функции SwapStringsInFile() из функции main() может быть следующим

void main()
{
  // Обмен местами двух строк в файле
  string filename = "TextFile1.txt"; // исходный файл
  int pos1 = 2; // исходная позиция строки 1
  int pos2 = 7; // исходная позиция строки 2

  if (SwapStringsInFile(filename,pos1, pos2))
  {
    cout << "OK!!!";
  }
  else
  {
    cout << "Error";
  }
}

 

10. Функция ReverseStringsInFile(). Реверсирования строк файла (перестановка строк файла в обратном порядке)

Алгоритм метода следующий:

  • считать строки из файла и записать их в массив;
  • обменять местами элементы массива так, чтобы строки массива размещались в обратном порядке;
  • записать измененный массив снова в файл

Текст функции ReverseStringsInFile() следующий

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция, которая обращает строки файла в обратном порядке.
// Параметры:
// - filename - имя файла.
// Если операция произошла успешно, то функция возвращает true.
bool ReverseStringsInFile(string filename)
{
  // 1. Объявить дополнительные переменные
  int count;
  string* lines = nullptr;
  string s;

  // 2. Считать строки из файла
  count = GetStringsFromFileS(filename, &lines);

  // 3. Проверка, считались ли строки корректно
  if (count <= 0) return false;

  // 4. Реверсирование массива lines
  for (int i = 0; i < count / 2; i++)
  {
    s = lines[i];
    lines[i] = lines[count - i - 1];
    lines[count - i - 1] = s;
  }

  // 5. Запись массива lines в файл
  bool res = SetStringsToFileS(filename, lines, count);

  // 6. Освободить память, выделенную для массива lines
  if (lines != nullptr) delete[] lines;

  // 7. Вернуть результат
  return res;
}

Использование ReverseStringsInFile () может быть, например, следующим

void main()
{
  // Реверсирование строк файла
  string filename = "TextFile3.txt"; // исходный файл

  if (ReverseStringsInFile(filename))
  {
    cout << "OK!!!";
  }
  else
  {
    cout << "Error";
  }
}

 

11. Функция SortStringsInFile(). Сортировка строк в файле

В примере демонстрируется сортировка строк файла с помощью метода вставки. Предварительно строки копируются в массив и там сортируются. Затем, отсортированный массив строк обратно записывается в файл.

#include <iostream>
using namespace std;

// модуль <fstream> необходим для работы с файлами
#include <fstream>

// Функция сортировки строк в файле методом вставки.
// Параметры:
// - filename - имя файла.
// Если сортировка произошла корректно, то функция возвращает true.
bool SortStringsInFile(string filename)
{
  // 1. Объявить дополнительные переменные
  int count;
  string* lines = nullptr;
  string s;

  // 2. Считать строки из файла в масив lines
  count = GetStringsFromFileS(filename, &lines); // функция описана в п.4

  // 3. Проверка, корректно ли считались строки
  if (count < 0) return false;

  // 4. Сортировка строк в файле по возрастанию методом вставки
  for (int i = 0; i < count - 1; i++)
    for (int j = i; j >= 0; j--)
      if (lines[j] > lines[j + 1])
      {
        s = lines[j];
        lines[j] = lines[j + 1];
        lines[j + 1] = s;
      }

  // 5. Записать отсортированный массив lines в файл
  bool res = SetStringsToFileS(filename, lines, count);

  // 6. Освободить память, выделенную для массива lines
  if (lines != nullptr) delete[] lines;

  // 7. Вернуть результат
  return res;
}

Использование файла в функции main()

void main()
{
  // Сортировка строк в файле
  string filename = "TextFile4.txt"; // исходный файл

  if (SortStringsInFile(filename))
  {
    cout << "OK!!!";
  }
  else
  {
    cout << "Error";
  }
}

 


Связанные темы

 


 

0
fb-share-icon20