Работа с файлами в С++. Произвольный доступ. Ознакомление
Произвольный доступ к файлам тема достаточно простая, но тем не менее способная немного запутывать новичков. Путает людей то, что файл обрабатывается или в двоичном, или в текстовом режиме. Из-за небольшого различия обработки может случаться видимость нерабочести. Иногда непривычно или трудно понимать термин курсор, когда не видишь курсора как такового. И наличие seekp, seekg, tellp, tellg. Все эти мелочи в совокупности создают некоторого рода атмосферу неясности.
Произвольный доступ можно одинаково задействовать и для файлов, открытых в текстовом режиме, и для файлов, открытых в бинарном режиме.
В С++ используется две разновидности файловых курсоров: курсор чтения и курсор записи. В зависимости от действия: чтение из файла или запись в файл — выбирается seekp или seekg соответственно. В некоторых случаях они работают одинаково, но не стоит использовать их не по назначению. Кроме того, что можно принудительно установить курсор файла в любую произвольную позицию внутри файла, можно узнавать текущую позицию курсора. Здесь так же нужно разделять курсор чтения и курсор записи tellp и tellg.
- Методы позиционирования различаются для входных и выходных потоков: для входных потоков имена методов заканчиваются символом 'g' (от слова get), а методы выходных потоков заканчиваются символом 'p' (от слова put).
seekg
установить позицию чтения
seekp
установить позицию записи
tellg
узнать позицию курсора чтения
tellp
узнать позицию курсора записи
Удобнее всего с позиционированием работать в бинарных файлах. В текстовых файлах сложнее отслеживать нужную позицию, если, например, в текстовом файле записаны числа. Поскольку число состоит из нескольких цифр, то сколько на какое число нужно скакнуть, расчитывать утомительно и невыгодно. В бинарном же файле более простое для компьютера представление и нам достаточно знать количество байт, занимаемых типом, чтобы сделать скачок на нужную позицию в таком файле и необходимо знать порядок следования байт.
Поскольку нам обычно легче текстовые файлы понимать, я начну давать примеры именно с текстового файла.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
//Произвольное позиционирование в файле 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 легко получить различные коды из разного числа символов:
Символ
Код
Пояснение
#
35
код символа состоит из двух минимальных единиц информации: 3, 5
a
97
код символа состоит из двух минимальных единиц информации: 9, 7
x
120
код символа состоит из трёх минимальных единиц информации: 1, 2, 0
Важно помнить, что в С++ отсчёт начинается с нуля, поэтому в файлах, как и в индексах массивов, какая-нибудь 5-я позиция будет обозначать 6-й элемент:
Значение
A
B
C
D
E
F
Позиция
0
1
2
3
4
5
Из-за этой нестабильности, порождаемой кодами символов, в текстовых файлах удобно позиционироваться только когда в файлах хранится непосредственно набор символов или само позиционирование предполагает движения посимвольные. При хранении в текстовом файле строк, обозначающих (как вариант) целые числа, позиционироваться неудобно.
При работе с двоичными файлами не приходится думать о кодах символов, поэтому позиционирование в таких файлах выполняется относительно легко. Только в отличие от текстовых файлов нужно или использовать write/read, или перегружать операции >>/<<. Иначе — здравствуйте коды символов, сбивающие настройку позиционирования.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
//Произвольное позиционирование в файле 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(); } |
Поскольку в коде записываются числа, идущие по порядку, то легко посчитать, что мы ожидаем на выходе.
Числа в файле
5
6
7
8
9
10
11
12
13
14
Позиция числа
0
1
2
3
4
5
- Важная составляющая удобного позиционирования — ровный шаг
- Также важно внимательно смотреть на режим открытия файла. Легко забыть поменять текстовый на бинарный, что может создать иллюзию или нерабочести или неправильной работы.
Под неровным шагом понимается, что при прогулке по символьным кодам (символьные коды — это числа) для шага требуется когда 2, когда 3, а когда и другое число символов.
Будьте внимательны непосредственно к типам. Так, например, в листинге #1 в центре внимания тип char, он используется и в условии цикла, и для запоминания в файл, и для запоминания считанного из файла значения. А в листинге #2 в центре внимания оказывается тип int. Просто не запутайтесь, с чем работаете, здесь это совсем несложно.
Поскольку я именно читал произвольное значение из файла, то использовал seek с окончанием g: seekg. В случае необходимости изменения произвольного значения, следует использовать seekp.
Напишем код, который подменит каждое второе значение, сохранённое в файле, на 0 (ноль). Будем использовать бинарный режим. Это поможет нам избежать кривого шага и упростит решение. Чтобы не создавать страшную кашу, разобью поведение программы на отдельные функции: в зависимости от желания пользователя файл или будет создаваться новый, или читаться, или изменяться.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
//Произвольное позиционирование в файле, изменение хранимых данных 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(); } |
Чтобы посмотреть результат работы, для начала нужно создать файл (выбрать 1), потом можно посмотреть файл (выбрать 2), потом подменить хранимые данные (выбрать 3), потом снова посмотреть файл (выбрать 4). Пока что у меня сделано так, что программу для каждого действия надо каждый раз запускать заново. Если можете исправить — вперёд. Я же хочу акцентировать внимание на наиболее нужных частях кода, поэтому пока так.
Обращаю ваше внимание на проявление вашего внимания к каждой мелочи кода. Важно помнить, что файл можно затереть, если не открыть в правильном режиме. Такой результат плачевен. ofstream по умолчанию открывает файл в режиме trunc (усекает файл, эффект полного стирания). Чтобы этого избежать, можно добавить к режимам открытия ios::in, сиё действие отключит дерзкое поведение. Важно помнить, что для открытия файла в нужном режиме, при комбинациях режимов, используют не логические операции, а битовые. Ещё обязательно понимать, что смещение происходит не по числу, а по количеству байтов, количество байтов зависит от типа. Т. е. если я хочу сместиться, например, на три позиции, то правильный шаг будет
3 * sizeof(ЁМКОСТЬ_ТИПА)
Это обусловлено тем, что для разных типов разный шаг смещения. Чем шире тип — тем шире шаг.
Поскольку во время записи нет смысла отслеживать непосредственно достижение конца файла, нужно запомнить координату этого конца. Когда мы открываем файл для дозаписи в файл значений, курсор попадает в конец файла, это значение мы сразу запоминаем, чтобы ориентироваться на него.
|
1 |
int final_position = f1.tellp(); |
К сожалению, есть во всём этом деле и подводные камни. Основная проблема — код платформозависим. Зависимость происход из совокупности задействованных механизмов. Достаточно знать, что тип int, как и многие другие типы, имеет изменчивую вместимость байтов (вместимость напрямую зависит от компьютера). Этого хватает, чтобы делать выводы о платформозависимости кода. Каждый компьютер может записывать файл по-своему. На разных компьютерах вполне можно ожидать получение неодинаковых файлов. Кроме этого, есть незнакомое новичкам влияние порядка следования сохранения байтов. Есть два варианта: слева-направо и справа-налево. Слева-направо называется big-indian, справа-налево называется little-indian. В некоторых случаях можно использовать платформонезависимые типы. Но в случае с порядком следования байт остаётся надеяться только на соглашение использования одинакового порядка следования байт (или слева-направо, или справа-налево). Давайте немного исправим нашу программу, задействовав платформонезависимый тип.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
//Произвольное позиционирование в файле 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';; } |
Сейчас я подменил платформозависимый тип int платформонезависимым типом uint8_t. Поскольку я записываю в файл числа без знака, то выбран беззнаковый тип, представляющий собой целые числа, вмещающий в себя 8 бит. Тут нужно учитывать, какие числа записываются в файл, для этого нужны некоторые знания информатики и понимание битов, байтов. Поскольку я записываю числа 5..14, а 8 бит без знака способны уместить в себя любые целые числа из диапазона 0..28 — 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
В некоторых реализациях компиляторов таких типов может не быть.
Вам остаётся следить за вместимостью и помнить, что наименьший тип может представляться как символьный тип. Теоретически, все эти типы могут быть синонимами символьных типов.
Напишем ещё одну программу. В этот раз будем увеличивать каждое второе значение на некоторое число.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 |
//Произвольное позиционирование в файле 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';; } |
В листинге #4 добавлена функция file_update. Внутри этой функции написан код, благодаря которому в файле происходят обновления значений. Также обновлено основное меню. Поскольку каждый раз запускать программу достаточно неудобно, вынесем меню в отдельную функцию.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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; //записываемое в файл значение 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'; } |
Теперь немного удобнее. Наша программа умеет работать с файлом: создавать новый файл или перезаписывать существующий, читать файл, обнулять в файле каждое второе значение и обновлять в файле каждое второе значение. И выглядит всё достаточно неплохо. Дошлифовывать напильником элементы дизайна предоставляю вам, в моём приоритете только показать механизм написания кода и дать знать о возможном возникновении проблем. Поскольку мы обновляем значения, то разумно открывать файл в совмещённом режиме чтения и записи. Такой режим обработки часто портит читаемость кода, но в нашем случае он оправдан. Поскольку мы меняем существующее значение, то сначала это значение нужно читать, поэтому первым делом мы позиционируем курсор чтения. Курсор чтения спозиционировали, значение прочитали, значение изменили, значение записали. Вот и весь алгоритм.
К сожалению, с вещественными числами (числами с точкой) дела обстоят сложнее. Такие числа платформозависимы, но стандартной реализации подобной показанной относительно целых чисел, у них нет, поэтому для них либо изобретают костыли (что не очень правильно), либо прибегают к помощи разных библиотек. Также изобретают велосипед или используют дополнительные библиотеки, если пытаются добиться платформонезависимости больших целых чисел. Если метить в то, что программа будет создана для одной архитектуры, то можно показанное использовать и для вещественных чисел, и использовать любой встроенный тип, а не как у меня. В случае работы со структурами необходимо дополнительно учитывать выравнивания структур. Но в этой теме я ограничусь простейшими типами и показанными примерами. Буду надеяться, что описанного хватит для ознакомления с произвольным доступом, с некоторыми сложностями записи в файл (эти сложности касаются любой записи в файл данных: и с произвольным доступом, и с последовательным). С целью обновления значений иногда намного проще создавать новый файл на основе существующего путём копирования считываемых значений и подтасовки значений в нужных местах. Это оправдано, если файл маленький относительно вместимости системы. Но может случиться и так, что потребуется задействовать механизм произвольного доступа. В случае работы с произвольным доступом, как уже в этой статье оговаривалось несколько раз, необходимо резко повышать внимание и быть очень бдительным. Всякие мелочи так и заноровят вам напакостить.
Полезные ссылки:
Ответ ValeryLaptev на киберфоруме
Разница между seekg() и seekp() — C++
Некоторые гарантии для типов (на английском языке)
Ответ ValeryLaptev на киберфоруме
Разница между seekg() и seekp() — C++
Некоторые гарантии для типов (на английском языке)
И не забывайте читать учебники!
7 комментариев на «“Работа с файлами в С++. Произвольный доступ. Ознакомление”»
Добавить комментарий
Случайная книга в электронном формате
почему в первом аргументе write или read идет такое выражение: (char*)&переменная ?? почему не просто переменная?
Наверное, потому что в зависимости от системы просто указатель может транслироваться как в число, так и в символ.
Лично я без понятия, почему обязательно приводить адрес к Си-строке.
&переменная — это указатель.
Синтаксис пришёл из языка С. Функции read и write написаны так, что первым параметром им требуется указатель. А коли обычная переменная не может быть указателем, когда она не аргумент-неуказатель, то есть есть как есть и нужно отдавать функции указатель на char.
а когда читаешь с одного файла в режиме binary и записываешь в другой файл в режиме binary, то визуально в текстовом файле должен быть текст или иероглифы?
Не понятен вопрос. Если читаешь то, что записано в текстовом режиме, и потом записываешь это в другой фай, то будет видно как текст.
если читать и записывать все в бинарном режиме (с флагом ios::binary) с текстового файла в пустой, то во втором файле будет виден текст?
Как записано, так и будет видно.
Вот пример: первоначально запись идёт в текстовом режиме, потом записанный в текстовом режиме файл читается в бинарном режиме и в бинарном режиме записывается. Поскольку первичный файл был записан в текстовом режиме, то и конечный результат видно как обычный текст, а не как бинарный файл.
спс, понял что будет виден текст