Работа с файлами в С++. Произвольный доступ. Ознакомление

Опубликовано 21.03.2018 | Автор: admin

Произвольный доступ к файлам тема достаточно простая, но тем не менее способная немного запутывать новичков. Путает людей то, что файл обрабатывается или в двоичном, или в текстовом режиме. Из-за небольшого различия обработки может случаться видимость нерабочести. Иногда непривычно или трудно понимать термин курсор, когда не видишь курсора как такового. И наличие seekp, seekg, tellp, tellg. Все эти мелочи в совокупности создают некоторого рода атмосферу неясности.

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

В С++ используется две разновидности файловых курсоров: курсор чтения и курсор записи. В зависимости от действия: чтение из файла или запись в файл — выбирается seekp или seekg соответственно. В некоторых случаях они работают одинаково, но не стоит использовать их не по назначению. Кроме того, что можно принудительно установить курсор файла в любую произвольную позицию внутри файла, можно узнавать текущую позицию курсора. Здесь так же нужно разделять курсор чтения и курсор записи tellp и tellg.

Методы позиционирования различаются для входных и выходных потоков: для входных потоков имена методов заканчиваются символом 'g' (от слова get), а методы выходных потоков заканчиваются символом 'p' (от слова put).

seekg

установить позицию чтения

seekp

установить позицию записи

tellg

узнать позицию курсора чтения

tellp

узнать позицию курсора записи

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

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

//Произвольное позиционирование в файле		Visual Studio 17		Листинг #1
#include <iostream>
#include <fstream>

using namespace std;

int main() {
	const char* PATH = "C:\\MyFiles\\4.txt";

	/*ЗАПИСЬ В ФАЙЛ ЛВСЕХ СИМВОЛОВ АТИНСКОГО АЛФАВИТА*/
	ofstream f1(PATH);
	for (char i = 'A'; i < 'Z'; i++) {
		f1 << i;
	};
	f1.close();


	char value = 0;

	/*ЧТЕНИЕ ИЗ ФАЙЛА ПРОИЗВОЛЬНОГО СИМВОЛА*/
	ifstream f2(PATH);
	f2.seekg(5 * sizeof(char), ios::beg);	//<--- устанавливаем курсор чтения на (пятый + 1) символ
		 f2 >> value;						//считываем символ, курсор смещается на одну позицию вперёд
		 cout << value;						//узнаём считанное значение, это символ F
	f2.close();

	cin.get();
}

//Произвольное позиционирование в файле Visual Studio 17 Листинг #1

#include <iostream>

#include <fstream>

using namespace std;

int main() {

const char* PATH = "C:\\MyFiles\\4.txt";

/*ЗАПИСЬ В ФАЙЛ ЛВСЕХ СИМВОЛОВ АТИНСКОГО АЛФАВИТА*/

ofstream f1(PATH);

for (char i = 'A'; i < 'Z'; i++) {

f1 << i;

};

f1.close();

char value = 0;

/*ЧТЕНИЕ ИЗ ФАЙЛА ПРОИЗВОЛЬНОГО СИМВОЛА*/

ifstream f2(PATH);

f2.seekg(5 * sizeof(char), ios::beg); //<--- устанавливаем курсор чтения на (пятый + 1) символ

f2 >> value; //считываем символ, курсор смещается на одну позицию вперёд

cout << value; //узнаём считанное значение, это символ F

f2.close();

cin.get();

}

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

Так, например, в ASCII легко получить различные коды из разного числа символов:

Символ

Код

Пояснение

код символа состоит из двух минимальных единиц информации: 3, 5

код символа состоит из двух минимальных единиц информации: 9, 7

120

код символа состоит из трёх минимальных единиц информации: 1, 2, 0

Важно помнить, что в С++ отсчёт начинается с нуля, поэтому в файлах, как и в индексах массивов, какая-нибудь 5-я позиция будет обозначать 6-й элемент:

Значение

Позиция

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

При работе с двоичными файлами не приходится думать о кодах символов, поэтому позиционирование в таких файлах выполняется относительно легко. Только в отличие от текстовых файлов нужно или использовать write/read, или перегружать операции >>/<<. Иначе — здравствуйте коды символов, сбивающие настройку позиционирования.

//Произвольное позиционирование в файле		Visual Studio 17		Листинг #2
#include <iostream>
#include <fstream>

using namespace std;

int main() {
	const char* PATH = "C:\\MyFiles\\4.txt";

	/*ЗАПИСЬ В ФАЙЛ ЧИСЕЛ 5...14*/
	ofstream f1(PATH);
	for (int i = 5; i < 15; i++) {
		f1.write((char*)&i, sizeof(int));
	};
	f1.close();

	int value = 0;		//Обратите внимание, что тип для сохранения
						//считваемого значения был изменён относительно листинга #1

	/*ЧИТАЕМ ПРОИЗВОЛЬНОЕ ЗНАЧЕНИЕ ИЗ ФАЙЛА В ПЕРЕМЕННУЮ value*/
	ifstream f2(PATH);
		f2.seekg(5 * sizeof(int), ios::beg);	//смещаем курсор на 5 позиций от начала файла
		f2.read((char*)&value, sizeof(int));
		cout << value << '\n';		//на выводе получаем 10
	f2.close();

	cin.get();
}

//Произвольное позиционирование в файле Visual Studio 17 Листинг #2

#include <iostream>

#include <fstream>

using namespace std;

int main() {

const char* PATH = "C:\\MyFiles\\4.txt";

/*ЗАПИСЬ В ФАЙЛ ЧИСЕЛ 5...14*/

ofstream f1(PATH);

for (int i = 5; i < 15; i++) {

f1.write((char*)&i, sizeof(int));

};

f1.close();

int value = 0; //Обратите внимание, что тип для сохранения

//считваемого значения был изменён относительно листинга #1

/*ЧИТАЕМ ПРОИЗВОЛЬНОЕ ЗНАЧЕНИЕ ИЗ ФАЙЛА В ПЕРЕМЕННУЮ value*/

ifstream f2(PATH);

f2.seekg(5 * sizeof(int), ios::beg); //смещаем курсор на 5 позиций от начала файла

f2.read((char*)&value, sizeof(int));

cout << value << '\n'; //на выводе получаем 10

f2.close();

cin.get();

}

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

Числа в файле

Позиция числа

Важная составляющая удобного позиционирования — ровный шаг

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

Под неровным шагом понимается, что при прогулке по символьным кодам (символьные коды — это числа) для шага требуется когда 2, когда 3, а когда и другое число символов.

Будьте внимательны непосредственно к типам. Так, например, в листинге #1 в центре внимания тип char, он используется и в условии цикла, и для запоминания в файл, и для запоминания считанного из файла значения. А в листинге #2 в центре внимания оказывается тип int. Просто не запутайтесь, с чем работаете, здесь это совсем несложно.

Поскольку я именно читал произвольное значение из файла, то использовал seek с окончанием g: seekg. В случае необходимости изменения произвольного значения, следует использовать seekp.

Напишем код, который подменит каждое второе значение, сохранённое в файле, на 0 (ноль). Будем использовать бинарный режим. Это поможет нам избежать кривого шага и упростит решение. Чтобы не создавать страшную кашу, разобью поведение программы на отдельные функции: в зависимости от желания пользователя файл или будет создаваться новый, или читаться, или изменяться.

//Произвольное позиционирование в файле, изменение хранимых данных		Visual Studio 2017		Листинг #3.1
#include <iostream>
#include <fstream>

using namespace std;

/*ФУНКЦИЯ СОЗДАНИЯ НОВОГО ФАЙЛА*/
void file_create(const char* PATH) {
	ofstream f1(PATH, ios::binary);
	for (int i = 5; i < 15; i++) {
		f1.write((char*)&i, sizeof(int));
	}
	f1.close();
}

/*ФУНКЦИЯ ОБХОДА ФАЙЛА*/
void file_read(const char* PATH) {
	ifstream f1(PATH, ios::binary);
	int value = 0;

	while (!f1.eof()) {
		f1.read((char*)&value, sizeof(int));
		if (!f1) break;
		cout << value << '\n';
	}
	f1.close();
}

/*ФУНКЦИЯ ПЕРЕЗАПИСИ ЗНАЧЕНИЙ В ФАЙЛЕ*/
void file_change(const char* PATH) {
	ofstream f1(PATH, ios::in | ios::binary | ios::ate);
	int cursor = 1 * sizeof(int);		//Начальная позиция курсора будет смещена на 1 int
	int value = 0;						//записываемое в файл значение

	int final_position = f1.tellp();	//запоминаем позицию курсора (сейчас он мигает в конце файла, файл открыт для дозаписи в конец)


	while (cursor < final_position && f1.seekp(cursor, ios::beg)) {	//пока курсор не вылез за конец файла и смещение курсора даёт положительный ответ, выполняем запись в файл значений
		f1.write((char*)&value, sizeof(int));	//Записываем значение value в файл
		cursor += (2 * sizeof(int));			//Смещаем курсор на 2 int
	}

	f1.close();
}

int main() {
	const char* PATH = "C:\\MyFiles\\4.txt";

	int X = 0;


	cout << "OUR CASE: \n";
	cout << "1. create new file. \n";
	cout << "2. read file. \n";
	cout << "3. rechange file. \n";

	cin >> X;
	cout << "\n===========\n";
	switch (X)
	{
	case 1: file_create(PATH); break;
	case 2: file_read(PATH); break;
	case 3: file_change(PATH); break;

	default:
		break;
	}


	cin.get();
	cin.get();

}

//Произвольное позиционирование в файле, изменение хранимых данных Visual Studio 2017 Листинг #3.1

#include <iostream>

#include <fstream>

using namespace std;

/*ФУНКЦИЯ СОЗДАНИЯ НОВОГО ФАЙЛА*/

void file_create(const char* PATH) {

ofstream f1(PATH, ios::binary);

for (int i = 5; i < 15; i++) {

f1.write((char*)&i, sizeof(int));

}

f1.close();

}

/*ФУНКЦИЯ ОБХОДА ФАЙЛА*/

void file_read(const char* PATH) {

ifstream f1(PATH, ios::binary);

int value = 0;

while (!f1.eof()) {

f1.read((char*)&value, sizeof(int));

if (!f1) break;

cout << value << '\n';

}

f1.close();

}

/*ФУНКЦИЯ ПЕРЕЗАПИСИ ЗНАЧЕНИЙ В ФАЙЛЕ*/

void file_change(const char* PATH) {

ofstream f1(PATH, ios::in | ios::binary | ios::ate);

int cursor = 1 * sizeof(int); //Начальная позиция курсора будет смещена на 1 int

int value = 0; //записываемое в файл значение

int final_position = f1.tellp(); //запоминаем позицию курсора (сейчас он мигает в конце файла, файл открыт для дозаписи в конец)

while (cursor < final_position && f1.seekp(cursor, ios::beg)) { //пока курсор не вылез за конец файла и смещение курсора даёт положительный ответ, выполняем запись в файл значений

f1.write((char*)&value, sizeof(int)); //Записываем значение value в файл

cursor += (2 * sizeof(int)); //Смещаем курсор на 2 int

}

f1.close();

}

int main() {

const char* PATH = "C:\\MyFiles\\4.txt";

int X = 0;

cout << "OUR CASE: \n";

cout << "1. create new file. \n";

cout << "2. read file. \n";

cout << "3. rechange file. \n";

cin >> X;

cout << "\n===========\n";

switch (X)

{

case 1: file_create(PATH); break;

case 2: file_read(PATH); break;

case 3: file_change(PATH); break;

default:

break;

}

cin.get();

}

Чтобы посмотреть результат работы, для начала нужно создать файл (выбрать 1), потом можно посмотреть файл (выбрать 2), потом подменить хранимые данные (выбрать 3), потом снова посмотреть файл (выбрать 4). Пока что у меня сделано так, что программу для каждого действия надо каждый раз запускать заново. Если можете исправить — вперёд. Я же хочу акцентировать внимание на наиболее нужных частях кода, поэтому пока так.

Обращаю ваше внимание на проявление вашего внимания к каждой мелочи кода. Важно помнить, что файл можно затереть, если не открыть в правильном режиме. Такой результат плачевен. ofstream по умолчанию открывает файл в режиме trunc (усекает файл, эффект полного стирания). Чтобы этого избежать, можно добавить к режимам открытия ios::in, сиё действие отключит дерзкое поведение. Важно помнить, что для открытия файла в нужном режиме, при комбинациях режимов, используют не логические операции, а битовые. Ещё обязательно понимать, что смещение происходит не по числу, а по количеству байтов, количество байтов зависит от типа. Т. е. если я хочу сместиться, например, на три позиции, то правильный шаг будет

3 * sizeof(ЁМКОСТЬ_ТИПА)

Это обусловлено тем, что для разных типов разный шаг смещения. Чем шире тип — тем шире шаг.

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

int final_position = f1.tellp();

1	int final_position = f1.tellp();

К сожалению, есть во всём этом деле и подводные камни. Основная проблема — код платформозависим. Зависимость происход из совокупности задействованных механизмов. Достаточно знать, что тип int, как и многие другие типы, имеет изменчивую вместимость байтов (вместимость напрямую зависит от компьютера). Этого хватает, чтобы делать выводы о платформозависимости кода. Каждый компьютер может записывать файл по-своему. На разных компьютерах вполне можно ожидать получение неодинаковых файлов. Кроме этого, есть незнакомое новичкам влияние порядка следования сохранения байтов. Есть два варианта: слева-направо и справа-налево. Слева-направо называется big-indian, справа-налево называется little-indian. В некоторых случаях можно использовать платформонезависимые типы. Но в случае с порядком следования байт остаётся надеяться только на соглашение использования одинакового порядка следования байт (или слева-направо, или справа-налево). Давайте немного исправим нашу программу, задействовав платформонезависимый тип.

//Произвольное позиционирование в файле		Visual Studio 17		Листинг #3.2
#include <iostream>
#include <fstream>
#include <cstdint>

using namespace std;

/*ФУНКЦИЯ СОЗДАНИЯ НОВОГО ФАЙЛА*/
void file_create(const char* PATH) {
	ofstream f1(PATH, ios::binary);
	for (uint8_t i = 5; i < 15; i++) {
		f1.write((char*)&i, sizeof(uint8_t));
	}
	f1.close();
}

/*ФУНКЦИЯ ОБХОДА ФАЙЛА*/
void file_read(const char* PATH) {
	ifstream f1(PATH, ios::binary);
	uint8_t value = 0;

	while (!f1.eof()) {
		f1.read((char*)&value, sizeof(uint8_t));
		if (!f1) break;
		cout << static_cast<int>(value) << '\n';		//После кода пояснение нужности приведения типа
	}
	f1.close();
}

/*ФУНКЦИЯ ПЕРЕЗАПИСИ ЗНАЧЕНИЙ В ФАЙЛЕ*/
void file_change(const char* PATH) {
	ofstream f1(PATH, ios::in | ios::binary | ios::ate);
	uint8_t cursor = 1 * sizeof(uint8_t);		//Начальная позиция курсора будет смещена на 1 uint8_t
	uint8_t value = 0;						//записываемое в файл значение

	uint8_t final_position = f1.tellp();	//запоминаем позицию курсора (сейчас он мигает в конце файла, файл открыт для дозаписи в конец)


	while (cursor < final_position && f1.seekp(cursor, ios::beg)) {	//пока курсор не вылез за конец файла и смещение курсора даёт положительный ответ, выполняем запись в файл значений
		f1.write((char*)&value, sizeof(uint8_t));	//Записываем значение value в файл
		cursor += (2 * sizeof(uint8_t));			//Смещаем курсор на 2 uint8_t
	}

	f1.close();
}

int main() {
	const char* PATH = "C:\\MyFiles\\4.txt";

	int X = 0;


	cout << "OUR CASE: \n";
	cout << "1. create new file. \n";
	cout << "2. read file. \n";
	cout << "3. rechange file. \n";

	cin >> X;
	cout << "\n===========\n";
	switch (X)
	{
	case 1: file_create(PATH); break;
	case 2: file_read(PATH); break;
	case 3: file_change(PATH); break;

	default:
		break;
	}


	cin.get();
	cin.get();

	cout << sizeof(uint8_t) << '\n';;

}

//Произвольное позиционирование в файле Visual Studio 17 Листинг #3.2

#include <iostream>

#include <fstream>

#include <cstdint>

using namespace std;

/*ФУНКЦИЯ СОЗДАНИЯ НОВОГО ФАЙЛА*/

void file_create(const char* PATH) {

ofstream f1(PATH, ios::binary);

for (uint8_t i = 5; i < 15; i++) {

f1.write((char*)&i, sizeof(uint8_t));

}

f1.close();

}

/*ФУНКЦИЯ ОБХОДА ФАЙЛА*/

void file_read(const char* PATH) {

ifstream f1(PATH, ios::binary);

uint8_t value = 0;

while (!f1.eof()) {

f1.read((char*)&value, sizeof(uint8_t));

if (!f1) break;

cout << static_cast<int>(value) << '\n'; //После кода пояснение нужности приведения типа

}

f1.close();

}

/*ФУНКЦИЯ ПЕРЕЗАПИСИ ЗНАЧЕНИЙ В ФАЙЛЕ*/

void file_change(const char* PATH) {

ofstream f1(PATH, ios::in | ios::binary | ios::ate);

uint8_t cursor = 1 * sizeof(uint8_t); //Начальная позиция курсора будет смещена на 1 uint8_t

uint8_t value = 0; //записываемое в файл значение

uint8_t final_position = f1.tellp(); //запоминаем позицию курсора (сейчас он мигает в конце файла, файл открыт для дозаписи в конец)

f1.write((char*)&value, sizeof(uint8_t)); //Записываем значение value в файл

cursor += (2 * sizeof(uint8_t)); //Смещаем курсор на 2 uint8_t

}

f1.close();

}

int main() {

const char* PATH = "C:\\MyFiles\\4.txt";

int X = 0;

cout << "OUR CASE: \n";

cout << "1. create new file. \n";

cout << "2. read file. \n";

cout << "3. rechange file. \n";

cin >> X;

cout << "\n===========\n";

switch (X)

{

case 1: file_create(PATH); break;

case 2: file_read(PATH); break;

case 3: file_change(PATH); break;

default:

break;

}

cin.get();

cout << sizeof(uint8_t) << '\n';;

}

Сейчас я подменил платформозависимый тип int платформонезависимым типом uint8_t. Поскольку я записываю в файл числа без знака, то выбран беззнаковый тип, представляющий собой целые числа, вмещающий в себя 8 бит. Тут нужно учитывать, какие числа записываются в файл, для этого нужны некоторые знания информатики и понимание битов, байтов. Поскольку я записываю числа 5..14, а 8 бит без знака способны уместить в себя любые целые числа из диапазона 0..2⁸ — 1, то мои числа принадлежат диапазону. Но в моём случае возникает необходимость приведения типов при выводе значения на экран. Когда я вывожу операцией << значение переменной типа uint8_t на экран, мне выводится не число, а символ. Так реализован тип uint8_t на моём компьютере: он является синонимом типа unsigned char, на вашем компьютере может быть иначе. Из-за этой детали приходится принудительно приводить значение к числу при выводе на экран. Как реализовано у вас, можно подсмотреть в файле stdint.h. Но если вы нацелены использовать файл на разных компьютерах, то для предупреждения неправильного вывода лучше насильно приведите выводимый тип к числу.

Есть несколько платформонезависимых целочисленных типов:

8 бит

16 бит

32 бита

64 бита

знаковые (signed)

int8_t

int16_t

int32_t

int64_t

беззнаковые (unsigned)

uint8_t

uint16_t

uint32_t

uint64_t

В некоторых реализациях компиляторов таких типов может не быть.

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

Напишем ещё одну программу. В этот раз будем увеличивать каждое второе значение на некоторое число.

//Произвольное позиционирование в файле		Visual Studio 17		Листинг #4.1
#include <iostream>
#include <fstream>
#include <cstdint>

using namespace std;

/*ФУНКЦИЯ СОЗДАНИЯ НОВОГО ФАЙЛА*/
void file_create(const char* PATH) {
	ofstream f1(PATH, ios::binary);
	for (uint8_t i = 5; i < 15; i++) {
		f1.write((char*)&i, sizeof(uint8_t));
	}
	f1.close();
}

/*ФУНКЦИЯ ОБХОДА ФАЙЛА*/
void file_read(const char* PATH) {
	ifstream f1(PATH, ios::binary);
	uint8_t value = 0;

	while (!f1.eof()) {
		f1.read((char*)&value, sizeof(uint8_t));
		if (!f1) break;
		cout << static_cast<int>(value) << '\n';		//После кода пояснение нужности приведения типа
	}
	f1.close();
}

/*ФУНКЦИЯ ПЕРЕЗАПИСИ ЗНАЧЕНИЙ В ФАЙЛЕ*/
void file_change(const char* PATH) {
	ofstream f1(PATH, ios::in | ios::binary | ios::ate);
	uint8_t cursor = 1 * sizeof(uint8_t);		//Начальная позиция курсора будет смещена на 1 uint8_t
	uint8_t value = 0;						//записываемое в файл значение

	streampos final_position = f1.tellp();	//запоминаем позицию курсора (сейчас он мигает в конце файла, файл открыт для дозаписи в конец)


	while (cursor < final_position && f1.seekp(cursor, ios::beg)) {	//пока курсор не вылез за конец файла и смещение курсора даёт положительный ответ, выполняем запись в файл значений
		f1.write((char*)&value, sizeof(uint8_t));	//Записываем значение value в файл
		cursor += (2 * sizeof(uint8_t));			//Смещаем курсор на 2 uint8_t
	}

	f1.close();
}

void file_update(const char* PATH) {
	uint8_t value;										//считываемое из файла значение
	fstream f1(PATH, ios::in | ios::out | ios::ate);	//поток открыт одновременно и для записи и для чтения

	int cursor = 1 * sizeof(int8_t);		//начальная позиция курсора смещена на одно значение, на int8_t байтов


	while (f1.seekg(cursor, ios::beg)) {		//двигаем курсор, пока двигается

		if (!f1.read((char*)&value, sizeof(value))) {	//читаем значение из файла и запоминаем его в value
			break;		//если попытка очередного чтения выключила флаг f1.good(), выходим из while
		}

		if (f1.seekp(cursor, ios::beg)) {			//устанавливаем курсор для записи на позицию
			value += 10;							//если всё хорошо, то изменяем прочитанное число
			f1.write((char*)&value, sizeof(value)); //и записываем это число поверх прочтённого
		}

		cursor += 2 * sizeof(uint8_t);				//обязательно двигаем курсор на новое число
	}
}

int main() {
	const char* PATH = "C:\\MyFiles\\4.txt";

	int X = 0;

	cout << "OUR CASE: \n";
	cout << "1. create new file. \n";
	cout << "2. read file. \n";
	cout << "3. rechange file. \n";
	cout << "4. update file. \n";

	cin >> X;
	cout << "\n===========\n";
	switch (X)
	{
	case 1: file_create(PATH); break;
	case 2: file_read(PATH); break;
	case 3: file_change(PATH); break;
	case 4: file_update(PATH); break;
	default:
		break;
	}

	cin.get();
	cin.get();

	cout << sizeof(uint8_t) << '\n';;

}

//Произвольное позиционирование в файле Visual Studio 17 Листинг #4.1

#include <iostream>

#include <fstream>

#include <cstdint>

using namespace std;

/*ФУНКЦИЯ СОЗДАНИЯ НОВОГО ФАЙЛА*/

void file_create(const char* PATH) {

ofstream f1(PATH, ios::binary);

for (uint8_t i = 5; i < 15; i++) {

f1.write((char*)&i, sizeof(uint8_t));

}

f1.close();

}

/*ФУНКЦИЯ ОБХОДА ФАЙЛА*/

void file_read(const char* PATH) {

ifstream f1(PATH, ios::binary);

uint8_t value = 0;

while (!f1.eof()) {

f1.read((char*)&value, sizeof(uint8_t));

if (!f1) break;

cout << static_cast<int>(value) << '\n'; //После кода пояснение нужности приведения типа

}

f1.close();

}

/*ФУНКЦИЯ ПЕРЕЗАПИСИ ЗНАЧЕНИЙ В ФАЙЛЕ*/

void file_change(const char* PATH) {

ofstream f1(PATH, ios::in | ios::binary | ios::ate);

uint8_t cursor = 1 * sizeof(uint8_t); //Начальная позиция курсора будет смещена на 1 uint8_t

uint8_t value = 0; //записываемое в файл значение

streampos final_position = f1.tellp(); //запоминаем позицию курсора (сейчас он мигает в конце файла, файл открыт для дозаписи в конец)

f1.write((char*)&value, sizeof(uint8_t)); //Записываем значение value в файл

cursor += (2 * sizeof(uint8_t)); //Смещаем курсор на 2 uint8_t

}

f1.close();

}

void file_update(const char* PATH) {

uint8_t value; //считываемое из файла значение

fstream f1(PATH, ios::in | ios::out | ios::ate); //поток открыт одновременно и для записи и для чтения

int cursor = 1 * sizeof(int8_t); //начальная позиция курсора смещена на одно значение, на int8_t байтов

while (f1.seekg(cursor, ios::beg)) { //двигаем курсор, пока двигается

if (!f1.read((char*)&value, sizeof(value))) { //читаем значение из файла и запоминаем его в value

break; //если попытка очередного чтения выключила флаг f1.good(), выходим из while

}

if (f1.seekp(cursor, ios::beg)) { //устанавливаем курсор для записи на позицию

value += 10; //если всё хорошо, то изменяем прочитанное число

f1.write((char*)&value, sizeof(value)); //и записываем это число поверх прочтённого

}

cursor += 2 * sizeof(uint8_t); //обязательно двигаем курсор на новое число

}

int main() {

const char* PATH = "C:\\MyFiles\\4.txt";

int X = 0;

cout << "OUR CASE: \n";

cout << "1. create new file. \n";

cout << "2. read file. \n";

cout << "3. rechange file. \n";

cout << "4. update file. \n";

cin >> X;

cout << "\n===========\n";

switch (X)

{

case 1: file_create(PATH); break;

case 2: file_read(PATH); break;

case 3: file_change(PATH); break;

case 4: file_update(PATH); break;

default:

break;

}

cin.get();

cout << sizeof(uint8_t) << '\n';;

}

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

//Произвольное позиционирование в файле		Visual Studio 17		Листинг #4.2
#include <iostream>
#include <fstream>
#include <cstdint>

using namespace std;

/*ФУНКЦИЯ СОЗДАНИЯ НОВОГО ФАЙЛА*/
void file_create(const char* PATH) {
	ofstream f1(PATH, ios::binary);
	for (uint8_t i = 5; i < 15; i++) {
		f1.write((char*)&i, sizeof(uint8_t));
	}
	f1.close();
}

/*ФУНКЦИЯ ОБХОДА ФАЙЛА*/
void file_read(const char* PATH) {
	ifstream f1(PATH, ios::binary);
	uint8_t value = 0;

	while (!f1.eof()) {
		f1.read((char*)&value, sizeof(uint8_t));
		if (!f1) break;
		cout << static_cast<int>(value) << '\n';		//После кода пояснение нужности приведения типа
	}
	f1.close();
}

/*ФУНКЦИЯ ПЕРЕЗАПИСИ ЗНАЧЕНИЙ В ФАЙЛЕ*/
void file_change(const char* PATH) {
	ofstream f1(PATH, ios::in | ios::binary | ios::ate);
	uint8_t cursor = 1 * sizeof(uint8_t);		//Начальная позиция курсора будет смещена на 1 uint8_t
	uint8_t value = 0;						//записываемое в файл значение

	streampos final_position = f1.tellp();	//запоминаем позицию курсора (сейчас он мигает в конце файла, файл открыт для дозаписи в конец)


	while (cursor < final_position && f1.seekp(cursor, ios::beg)) {	//пока курсор не вылез за конец файла и смещение курсора даёт положительный ответ, выполняем запись в файл значений
		f1.write((char*)&value, sizeof(uint8_t));	//Записываем значение value в файл
		cursor += (2 * sizeof(uint8_t));			//Смещаем курсор на 2 uint8_t
	}

	f1.close();
}

void file_update(const char* PATH) {
	uint8_t value;										//считываемое из файла значение
	fstream f1(PATH, ios::in | ios::out | ios::ate);	//поток открыт одновременно и для записи и для чтения

	int cursor = 1 * sizeof(int8_t);		//начальная позиция курсора смещена на одно значение, на int8_t байтов


	while (f1.seekg(cursor, ios::beg)) {		//двигаем курсор, пока двигается

		if (!f1.read((char*)&value, sizeof(value))) {	//читаем значение из файла и запоминаем его в value
			break;		//если попытка очередного чтения выключила флаг f1.good(), выходим из while
		}

		if (f1.seekp(cursor, ios::beg)) {			//устанавливаем курсор для записи на позицию
			value += 10;							//если всё хорошо, то изменяем прочитанное число
			f1.write((char*)&value, sizeof(value)); //и записываем это число поверх прочтённого
		}

		cursor += 2 * sizeof(uint8_t);				//обязательно двигаем курсор на новое число
	}
}

bool menu(const char* PATH) {
	int X = 0;

	cout << "OUR CASE: \n";
	cout << "1. create new file. \n";
	cout << "2. read file. \n";
	cout << "3. rechange file. \n";
	cout << "4. update file. \n";
	cout << "0. exit \n";

	cin >> X;
	cout << "\n===========\n";
	switch (X)
	{
	case 1: file_create(PATH); break;
	case 2: file_read(PATH); break;
	case 3: file_change(PATH); break;
	case 4: file_update(PATH); break;

	default:
		cout << "\n===========\n";
		return false;
	}
	cout << "\n===========\n";
	return true;
}

int main() {
	const char* PATH = "C:\\MyFiles\\4.txt";


	while (menu(PATH));


	cin.get();
	cin.get();

	cout << sizeof(uint8_t) << '\n';

}

100

101

102

103

104

105

106

107

108

//Произвольное позиционирование в файле Visual Studio 17 Листинг #4.2

#include <iostream>

#include <fstream>

#include <cstdint>

using namespace std;

/*ФУНКЦИЯ СОЗДАНИЯ НОВОГО ФАЙЛА*/

void file_create(const char* PATH) {

ofstream f1(PATH, ios::binary);

for (uint8_t i = 5; i < 15; i++) {

f1.write((char*)&i, sizeof(uint8_t));

}

f1.close();

}

/*ФУНКЦИЯ ОБХОДА ФАЙЛА*/

void file_read(const char* PATH) {

ifstream f1(PATH, ios::binary);

uint8_t value = 0;

while (!f1.eof()) {

f1.read((char*)&value, sizeof(uint8_t));

if (!f1) break;

cout << static_cast<int>(value) << '\n'; //После кода пояснение нужности приведения типа

}

f1.close();

}

/*ФУНКЦИЯ ПЕРЕЗАПИСИ ЗНАЧЕНИЙ В ФАЙЛЕ*/

void file_change(const char* PATH) {

ofstream f1(PATH, ios::in | ios::binary | ios::ate);

uint8_t cursor = 1 * sizeof(uint8_t); //Начальная позиция курсора будет смещена на 1 uint8_t

uint8_t value = 0; //записываемое в файл значение

f1.write((char*)&value, sizeof(uint8_t)); //Записываем значение value в файл

cursor += (2 * sizeof(uint8_t)); //Смещаем курсор на 2 uint8_t

}

f1.close();

}

void file_update(const char* PATH) {

uint8_t value; //считываемое из файла значение

fstream f1(PATH, ios::in | ios::out | ios::ate); //поток открыт одновременно и для записи и для чтения

int cursor = 1 * sizeof(int8_t); //начальная позиция курсора смещена на одно значение, на int8_t байтов

while (f1.seekg(cursor, ios::beg)) { //двигаем курсор, пока двигается

if (!f1.read((char*)&value, sizeof(value))) { //читаем значение из файла и запоминаем его в value

break; //если попытка очередного чтения выключила флаг f1.good(), выходим из while

}

if (f1.seekp(cursor, ios::beg)) { //устанавливаем курсор для записи на позицию

value += 10; //если всё хорошо, то изменяем прочитанное число

f1.write((char*)&value, sizeof(value)); //и записываем это число поверх прочтённого

}

cursor += 2 * sizeof(uint8_t); //обязательно двигаем курсор на новое число

}

bool menu(const char* PATH) {

int X = 0;

cout << "OUR CASE: \n";

cout << "1. create new file. \n";

cout << "2. read file. \n";

cout << "3. rechange file. \n";

cout << "4. update file. \n";

cout << "0. exit \n";

cin >> X;

cout << "\n===========\n";

switch (X)

{

case 1: file_create(PATH); break;

case 2: file_read(PATH); break;

case 3: file_change(PATH); break;

case 4: file_update(PATH); break;

default:

cout << "\n===========\n";

return false;

}

cout << "\n===========\n";

return true;

}

int main() {

const char* PATH = "C:\\MyFiles\\4.txt";

while (menu(PATH));

cin.get();

cout << sizeof(uint8_t) << '\n';

}

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

К сожалению, с вещественными числами (числами с точкой) дела обстоят сложнее. Такие числа платформозависимы, но стандартной реализации подобной показанной относительно целых чисел, у них нет, поэтому для них либо изобретают костыли (что не очень правильно), либо прибегают к помощи разных библиотек. Также изобретают велосипед или используют дополнительные библиотеки, если пытаются добиться платформонезависимости больших целых чисел. Если метить в то, что программа будет создана для одной архитектуры, то можно показанное использовать и для вещественных чисел, и использовать любой встроенный тип, а не как у меня. В случае работы со структурами необходимо дополнительно учитывать выравнивания структур. Но в этой теме я ограничусь простейшими типами и показанными примерами. Буду надеяться, что описанного хватит для ознакомления с произвольным доступом, с некоторыми сложностями записи в файл (эти сложности касаются любой записи в файл данных: и с произвольным доступом, и с последовательным). С целью обновления значений иногда намного проще создавать новый файл на основе существующего путём копирования считываемых значений и подтасовки значений в нужных местах. Это оправдано, если файл маленький относительно вместимости системы. Но может случиться и так, что потребуется задействовать механизм произвольного доступа. В случае работы с произвольным доступом, как уже в этой статье оговаривалось несколько раз, необходимо резко повышать внимание и быть очень бдительным. Всякие мелочи так и заноровят вам напакостить.

Полезные ссылки:
Ответ ValeryLaptev на киберфоруме
Разница между seekg() и seekp() — C++
Некоторые гарантии для типов (на английском языке)

И не забывайте читать учебники!

Рубрика: Базовые знания, level "HelloWorld", Решения задач, Теоретическая нагрузка, Файлы

Igor:

28.04.2018 в 6:39 пп

почему в первом аргументе write или read идет такое выражение: (char*)&переменная ?? почему не просто переменная?

Ответить

admin:

28.04.2018 в 6:49 пп

Наверное, потому что в зависимости от системы просто указатель может транслироваться как в число, так и в символ.
Лично я без понятия, почему обязательно приводить адрес к Си-строке.

&переменная — это указатель.

Синтаксис пришёл из языка С. Функции read и write написаны так, что первым параметром им требуется указатель. А коли обычная переменная не может быть указателем, когда она не аргумент-неуказатель, то есть есть как есть и нужно отдавать функции указатель на char.

Ответить

28.04.2018 в 7:28 пп

а когда читаешь с одного файла в режиме binary и записываешь в другой файл в режиме binary, то визуально в текстовом файле должен быть текст или иероглифы?

admin:

28.04.2018 в 7:33 пп

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

Ответить

28.04.2018 в 7:44 пп

если читать и записывать все в бинарном режиме (с флагом ios::binary) с текстового файла в пустой, то во втором файле будет виден текст?

admin:

28.04.2018 в 8:32 пп

Как записано, так и будет видно.

Вот пример: первоначально запись идёт в текстовом режиме, потом записанный в текстовом режиме файл читается в бинарном режиме и в бинарном режиме записывается. Поскольку первичный файл был записан в текстовом режиме, то и конечный результат видно как обычный текст, а не как бинарный файл.

#include <iostream>
#include <fstream>
#include <cstring>

using namespace std;



int main(){
    const char* BASE_FILE = "input.txt";
    const char* BINARY_FILE = "output.txt";
//Запись тестируемого файла. Сейчас режим текстовый
   ofstream textfile(BASE_FILE);
      textfile << "test text string";
    textfile.close();

    ifstream binary_read(BASE_FILE, ios::binary);   //поток бинарного чтения
    ofstream binary_write(BINARY_FILE, ios::binary); //поток бинарной записи
    char ch;
       while (binary_read.good()){
        binary_read.read((char*)&ch, sizeof(ch));
        if (binary_read.eof()) break; //чтобы не читать дважды последний символ файла
        //std::cout << ch;
        /**********************/
            binary_write.write((char*)&ch, sizeof(ch)); //запись, режим бинарный (ибо объявлено раньше, что бинарный)
        /**********************/
       }
    binary_write.close();
    binary_read.close();

    /*РЕЗУЛЬТАТ*/
    ifstream result(BINARY_FILE);       //в текстовом режиме
        while (result.good()){
            ch = result.get();
            if (ch == result.eof()) break;
            cout << ch;
        }
    result.close();
}

#include <cstring>

const char* BASE_FILE = "input.txt";

const char* BINARY_FILE = "output.txt";

//Запись тестируемого файла. Сейчас режим текстовый

ofstream textfile(BASE_FILE);

textfile << "test text string";

textfile.close();

ifstream binary_read(BASE_FILE, ios::binary); //поток бинарного чтения

ofstream binary_write(BINARY_FILE, ios::binary); //поток бинарной записи

char ch;

while (binary_read.good()){

binary_read.read((char*)&ch, sizeof(ch));

if (binary_read.eof()) break; //чтобы не читать дважды последний символ файла

//std::cout << ch;

/**********************/

binary_write.write((char*)&ch, sizeof(ch)); //запись, режим бинарный (ибо объявлено раньше, что бинарный)

binary_write.close();

binary_read.close();

/*РЕЗУЛЬТАТ*/

ifstream result(BINARY_FILE); //в текстовом режиме

while (result.good()){

ch = result.get();

if (ch == result.eof()) break;

cout << ch;

result.close();

28.04.2018 в 8:45 пп

спс, понял что будет виден текст

Работа с файлами в С++. Произвольный доступ. Ознакомление

7 комментариев на «“Работа с файлами в С++. Произвольный доступ. Ознакомление”»

Добавить комментарий Отменить ответ

Поиск

Последние темы

Случайная книга в электронном формате

Последние комментарии

Мета