Запись в бинарный файл простых массивов структур
Иногда в файл нужно записывать массив структур. В случае необходимости записи массива структур в бинарный файл, наиболее выгодным способом является способ, где в файл сначала записывается число, обозначающее число элементов в массиве, а только потом сам массив структур. Если этого не делать, то издержки работы с файлом, открытым для чтения в бинарном режиме, двойной проход по файлу, где первый проход только для подсчёта числа элементов, а второй проход для непосредственного чтения значений. Разумеется, проще сразу записать число элементов, чтобы сэкономить время обработки.
Часто новички не различают разницу между массивами и указателями и называют указатель на массив массивом. Когда мы создаём массив с задаваемым числом элементов во время работы программы, тогда мы используем указатель на массив.
|
1 |
int *arr = new int[10]; //указатель на начало массива, состоящего из 10 элементов |
Поскольку из указателя на массив нельзя узнать размер массива с помощью операции sizeof, то при записи в файл в бинарном режиме нельзя взять и определить за раз, сколько байтов потребуется записать. Это немного неудобно. Тем не менее, в случае работы с массивом с зафиксированным числом элементов, когда заранее точно знаешь это число, возможно записывать в бинарный файл массив структур сразу. В таком случае будут мешать иные проблемы: выравнивания структур, использование типов внутри структур. Очень важно, чтобы в случае записи всего массива структур за раз внутри структуры не было указателей, а типы были простыми (pod-типы). Но не будем углубляться, смотрим пример:
|
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 |
//Запись массива структур в бинарный файл и чтение clang Листинг #1 #include <iostream> #include <fstream> using namespace std; #pragma pack (push, 1) struct MyContainer{ int x; double y; }; #pragma pack (pop) int main(){ const char* PATH = "C:\\MyFiles\\5.txt"; const int SIZE = 5; //Это размер массива MyContainer O[SIZE]; //Массив структур, умеет хранит 5 элементов типа MyContainer MyContainer R[SIZE]; //В этот массив будем читать значения из файла O[0].x = 10; O[0].y = 9; O[1].x = 8; O[1].y = 7; O[2].x = 6; O[2].y = 5; O[3].x = 4; O[3].y = 3; O[4].x = 2; O[4].y = 1; ofstream fo(PATH, ios::binary); //Записываем массив O в файл, бинарный режим fo.write((char*)O, sizeof(O)); fo.close(); ifstream fr(PATH, ios::binary); //Читаем файл и переносим значения в массив R fr.read((char*)R, sizeof(R)); fr.close(); //Обходим массив R for (unsigned i=0; i<SIZE; i++) { cout << R[i].x << ';' << R[i].y << '\n'; } } |
Оборачивание структуры директивой pragma необходимо для того, чтобы типы внутри структуры не уширялись.
- pragma pack(1) — упаковка данных, выравнивание по байту, эта прагма упаковывает структуру.
- В коде это использовано, чтобы правильно расписать структуру, чтобы она один в один ложилась на формат бинарного файла.
Несмотря на то, что выглядит это достаточно удобным, иногда такой способ записи/чтения может тормозить работу программы. Автоматические выравнивания структур появились не сами по себе, а потому что нужно было как-то оптимизировать работу для разных платформ. Малая часть всего комплекса оптимизаций, это как раз автоматическое выравнивание структур. По той причине, что принудительные выравнивания могут тормозить работу программы, а иногда даже приводить к падению программы (как утверждают некоторые люди), некоторые авторы не рекомендуют использовать директиву pragma pack. В таком случае остаётся только поэлементная запись и, разумеется, поэлементное чтение.
Поэлементная обработка массива структур может выглядеть вот так:
|
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 |
//Запись массива структур в бинарный файл и чтение clang Листинг #2 #include <iostream> #include <fstream> using namespace std; struct MyContainer{ int x; double y; }; int main(){ const char* PATH = "C:\\MyFiles\\5.txt"; const int SIZE = 5; //Это размер массива MyContainer O[SIZE]; //Массив структур, умеет хранит 5 элементов типа MyContainer MyContainer R[SIZE]; //В этот массив будем читать значения из файла O[0].x = 10; O[0].y = 9; O[1].x = 8; O[1].y = 7; O[2].x = 6; O[2].y = 5; O[3].x = 4; O[3].y = 3; O[4].x = 2; O[4].y = 1; ofstream fo(PATH, ios::binary); for (unsigned i=0; i<SIZE; i++){ fo.write((char*)&O[i].x, sizeof(O[i].x)); //Записали значение x fo.write((char*)&O[i].y, sizeof(O[i].y)); //записали значение y } fo.close(); ifstream fr(PATH, ios::binary); for (unsigned i=0; i<SIZE; i++){ fr.read((char*)&R[i].x, sizeof(O[i].x)); //Записали значение x fr.read((char*)&R[i].y, sizeof(O[i].y)); //Записали значение y } fr.close(); /*ОБХОДИМ*/ for (unsigned i=0; i<SIZE; i++) { cout << R[i].x << ';' << R[i].y << '\n'; } } |
Несмотря на то, что это работает, в этом коде есть подводные камни в виде платформозависимости. Может получиться так, что при смене версии компилятора или апгрейде оборудования файлы перестанут читаться так, как должны. Это не проблема структур, а проблема непосредственно обычных типов. Для целых типов в некоторых реализациях компиляторов присутствуют специальные переносимые типы, а для чисел с точкой всё сложнее. Я ограничусь обычными типами, ибо легко могу написать бред.
Рассмотрим пример работы с указателем внутри структуры. Для начала просто заполнение и вывод на экран без работы с файлом. Структура, отображаемая в примере, хранит одномерные массивы с разной ёмкостью. Для узнавания начала массивов используется указательная переменная, для узнавания числа вмещаемых элементов дополнительная переменная, обозначающая размер массива.
|
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 |
//Листинг #а1 структура с указательной переменной #include <iostream> #include <fstream> using namespace std; struct MyContainer{ int *x; int size_arr; }; int main(){ const char* PATH = "C:\\MyFiles\\5.txt"; const int SIZE = 5; //Это размер массива MyContainer values[SIZE]; //Массив структур называется values, вмещает SIZE структур типа MyContainer /*создаём несколько массивов структур*/ for (unsigned i=0; i<SIZE; i++){ values[i].size_arr = i + 5; values[i].x = new int[values[i].size_arr]; } /*Заполняем массивы значениями*/ int count = 0; for (unsigned i=0; i<SIZE; i++){ for (unsigned j=0; j<values[i].size_arr; j++){ values[i].x[j] = count++; //Записываем в массив число count } } for (unsigned i=0; i<SIZE; i++){ for (unsigned j=0; j<values[i].size_arr; j++){ cout << values[i].x[j] << '\t'; //Записываем в массив число count } cout << '\n'; } for (unsigned i=0; i<SIZE; i++){ delete []values[i].x; //Зачищаем указатели } } |
Даже в таком виде очевидны усложнения кода. Это одна из многих причин недолюбливания указательных переменных. Поскольку мы однозначно знаем, что именно представляет собой указатель: указывает на одномерный массив, а сама структура хранит достаточно данных для работы, такую структуру можно записать в файл, например, по разыменованию указательной переменной или по обращению к индексу массива, если указатель указывает на массив.
|
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 |
//Листинг #3 clang Запись в файл простой структуры с указателем Поэлементно #include <iostream> #include <fstream> using namespace std; /*НАША СТРУКТУРА, ЗАПИСЫВАЕМАЯ В ФАЙЛ*/ struct MyContainer{ int *x; int size_arr; }; int main(){ const char* PATH = "C:\\MyFiles\\5.txt"; const int SIZE = 5; //Это размер массива MyContainer values[SIZE]; //Массив структур называется values, вмещает SIZE структур типа MyContainer MyContainer R[SIZE]; //Массив структур называется R, вмещает SIZE структур типа MyContainer, будем в него переносить значения из файла /*создаём несколько массивов структур*/ for (unsigned i=0; i<SIZE; i++){ values[i].size_arr = i + 5; values[i].x = new int[values[i].size_arr]; } /*Заполняем массивы значениями*/ int count = 0; for (unsigned i=0; i<SIZE; i++){ for (unsigned j=0; j<values[i].size_arr; j++){ values[i].x[j] = count++; //Записываем в массив число count } } /*ЗАПИСЬ МАССИВА СТРУКТУР В ФАЙЛ*/ ofstream f1(PATH, ios::binary); for (unsigned i=0; i<SIZE; i++){ f1.write((char*)&values[i].size_arr, sizeof(values[i].size_arr)); //Сначала просто запись числа for (unsigned j=0; j<values[i].size_arr; j++){ //Потом обход по всему массиву!!! f1.write((char*)&values[i].x[j], sizeof(values[i].x[j])); //и запись каждого его значения } } f1.close(); /*НАМ МАССИВ values В НАСТОЯЩЕЕ ВРЕМЯ БОЛЬШЕ НЕ НУЖЕН, ЧИСТИМ ЕГО*/ for (unsigned i=0; i<SIZE; i++){ delete []values[i].x; } /*ЧТЕНИЕ ИЗ ФАЙЛА ЗНАЧЕНИЙ В МАССИВ СТРУКТУР*/ ifstream f2(PATH, ios::binary); for (unsigned i=0; i<SIZE; i++){ f2.read((char*)&R[i].size_arr, sizeof(R[i].size_arr)); R[i].x = new int[R[i].size_arr]; //При чтении обязательно не забыть выделить память!!! for (unsigned j=0; j<R[i].size_arr; j++){ f2.read((char*)&R[i].x[j], sizeof(R[i].x[j])); } } f2.close(); /*ВЫВОДИМ НА ЭКРАН ЗНАЧЕНИЯ*/ int temp_size = 0; for (unsigned i=0; i<SIZE; i++){ temp_size = R[i].size_arr; for (unsigned j=0; j<temp_size; j++){ cout << R[i].x[j] << '\t'; } cout << '\n'; } /*ОБЯЗАТЕЛЬНО ЧИСТИМ НЕНУЖНЫЙ МАССИВ, ЕСЛИ ДЛЯ ЕГО СОЗДАНИЯ БЫЛО new*/ for (unsigned i=0; i<SIZE; i++){ delete []R[i].x; } } |
Записать в файл можно и немного проще (в том смысле, что укоротить число строчек):
|
1 2 3 4 5 6 7 8 9 10 |
//Листинг #a2 /*ЗАПИСЬ МАССИВА СТРУКТУР В ФАЙЛ*/ ofstream f1(PATH, ios::binary); for (unsigned i=0; i<SIZE; i++){ f1.write((char*)&values[i].size_arr, sizeof(values[i].size_arr)); f1.write((char*)values[i].x, sizeof(values[i].x[0]) * values[i].size_arr); } f1.close(); |
Но как бы то ни было, не нужно долго пояснять, что такие коды достаточно сложно воспринимать взору нашему нежному. К тому же, чтение всё равно придётся делать поэлементное. Ведь на каждом шаге цикла мы узнаём, сколько памяти надо выделить, и только узнав ОБЯЗАТЕЛЬНО выделяем память с целью записи в эту память значения. Поскольку new int[] выделяет непрерывный блок памяти, имеется возможность записи блока сразу, миную поэлементный обход, что и демонстрируется в листинге #a2.
Можно использовать более удобное в плане использования решение, описав функции записи и чтения вовнутрь самой структуры. Это будет выглядеть так:
|
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 |
//Листинг #4 clang Запись в файл простой структуры с указателем Извнутри структуры #include <iostream> #include <fstream> using namespace std; /*НАША СТРУКТУРА, ЗАПИСЫВАЕМАЯ В ФАЙЛ*/ struct MyContainer{ int *x; int size_arr; void serialize(ofstream &f){ f.write((char*)&size_arr, sizeof(size_arr)); //записываем size_arr f.write((char*)x, sizeof(x[0]) * size_arr); //записываем массив, на который указывает указатель } void deserealize(ifstream &f){ f.read((char*)&size_arr, sizeof(size_arr)); //читаем size_arr x = new int[size_arr]; //выделяем память согласно считанному числу f.read((char*)x, sizeof(x[0]) * size_arr); //читаем непосредственно значения массива } /*ФУНКЦИЯ ВЫСВОБОЖДЕНИЯ ВЫДЕЛЕННОЙ ПАМЯТИ*/ void free(){ delete []x; x = 0; } void print(){ for (unsigned i=0; i<size_arr; i++){ cout << x[i] << '\t'; } } }; int main(){ setlocale(LC_ALL,""); const char* PATH = "C:\\MyFiles\\5.txt"; const int SIZE = 5; //Это размер массива MyContainer values[SIZE]; //Массив структур называется values, вмещает SIZE структур типа MyContainer MyContainer R[SIZE]; //Массив структур называется R, вмещает SIZE структур типа MyContainer, будем в него переносить значения из файла /*создаём несколько массивов структур*/ for (unsigned i=0; i<SIZE; i++){ values[i].size_arr = i + 5; values[i].x = new int[values[i].size_arr]; } /*Заполняем массивы значениями*/ int count = 0; for (unsigned i=0; i<SIZE; i++){ for (unsigned j=0; j<values[i].size_arr; j++){ values[i].x[j] = count++; //Записываем в массив число count } } /* ЗАПИСЬ ЗНАЧЕНИЙ В ФАЙЛ */ ofstream f1(PATH, ios::binary); for (int i=0; i<SIZE; i++){ values[i].serialize(f1); } f1.close(); /*очистка масива*/ for (unsigned i=0; i<SIZE; i++){ values[i].free(); } /* ЧТЕНИЕ ЗНАЧЕНИЙ ИЗ ФАЙЛА */ ifstream f2(PATH, ios::binary); for (unsigned i=0; i<SIZE; i++){ R[i].deserealize(f2); } f2.close(); /* ВЫВОД ЗНАЧЕНИЙ МАССИВА НА ЭКРАН */ for (unsigned i=0; i<SIZE; i++){ R[i].print(); cout << '\n'; } for (unsigned i=0; i<SIZE; i++){ R[i].free(); } } |
Это можно ещё улучшать. На данный момент я некоторых вещей не знаю, поэтому пока остановлюсь на том, что уже написал. Эти примеры прямой ключ к пониманию записи простых массивов структур в файл и чтение их оттуда. Лучше всего избегать указателей, потому что даже в простой ситуации вы могли увидеть как резко осложняется код.
Иногда встречается код, в котором внутри массива структур хранятся идентичные значения. В моих примерах значениями были массивы, ёмкость которых была различной. Если бы у каждого массива ёмкость была одной и той же, то наиболее употребимый вариант для такого случая — записать сначала в файл число, обозначающее число элементов масива структур, а потом записать саму структуру, и, соответственно, прочитать сначала число, а потом элементы структуры, ориентируясь на прочитанное число. Число файл увеличит совсем на чуть-чуть, а времени сэкономить может много.
|
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 |
//Запись массива структур в бинарный файл и чтение clang Листинг #5 #include <iostream> #include <fstream> using namespace std; /*НАША СТРУКТУРА, ЗАПИСЫВАЕМАЯ В ФАЙЛ*/ struct MyContainer{ int *x; }; int main(){ setlocale(LC_ALL,""); const char* PATH = "C:\\MyFiles\\5.txt"; const int SIZE_STRUCT = 10; //Это размер массива const int SIZE_X = 7; //Это размер массива, на который будет указывать указатель структуры unsigned value = 0; //Это значение для записи в структуру MyContainer *arr = new MyContainer[SIZE_STRUCT]; //Создаём массив из SIZE_STRUCT структур for (unsigned i=0; i<SIZE_STRUCT; i++){ arr[i].x = new int[SIZE_X]; //выделяем память каждому указателю (в каждом индексе массива сырой указатель) } /*ЗАПОЛНЕНИЕ МАССИВА СТРУКТУР ЗНАЧЕНИМИ*/ for (unsigned i=0; i<SIZE_STRUCT; i++){ for (unsigned j=0; j<SIZE_X; j++){ arr[i].x[j] = value++; } } /*ЗАПИСЬ МАССИВА СТРУКТУР В ФАЙЛ*/ ofstream f1(PATH, ios::binary); f1.write((char*)&SIZE_STRUCT, sizeof(SIZE_STRUCT)); //Сначала записали число, обозначающее вместимость массива структур for (unsigned i=0; i<SIZE_STRUCT; i++){ //Потом записали массив структур f1.write((char*)arr[i].x, sizeof(arr[i].x[0]) * SIZE_X); } f1.close(); for (unsigned i=0; i<SIZE_STRUCT; i++){ //Обходим внутренний масив структуры (тот, на который указывает указатель) delete []arr[i].x; //зачищаем каждую ячейку от указателей, к которым применялось new } delete []arr; //зачищаем основной массив /*ЭТО УЖЕ ЧТЕНИЕ*/ MyContainer *R; //Сырой указатель int size_arr = 0; //Размер массива, на который будет указывать R, позднее мы узнаем ему значение ifstream f2(PATH, ios::binary); f2.read((char*)&size_arr, sizeof(size_arr)); //Читаем из файла число в size_arr (число у нас записано в самом начале) R = new MyContainer[size_arr]; //Выделяем память общему массиву (массиву структур) согласно зачитанному числу /*выделяем память указателям, в каждой ячейке массива структур лежит сырой указатель*/ for (unsigned i=0; i<size_arr; i++){ R[i].x = new int[SIZE_X]; //Выделили память f2.read((char*)R[i].x, sizeof(R[i].x[0]) * SIZE_X); //Зачитали значения и сохранили их в выделенную память } f2.close(); /*ОБХОДИМ МАССИВ И ВЫВОДИМ ЗНАЧЕНИЯ НА ЭКРАН*/ for (unsigned i=0; i<size_arr; i++){ for (unsigned j=0; j<SIZE_X; j++){ cout << R[i].x[j] << '\t'; } cout << '\n'; } /*ЗАЧИЩАЕМ МАССИВ СТРУКТУР R*/ //Сначала чистим внутренню часть. for (unsigned i=0; i<size_arr; i++){ delete []R[i].x; //Почистили } //Потом чистим основу сиё хранящее delete []R; } |
Разумеется, для того, чтобы это проделывать и хоть что-то понимать, нужны неплохие знания и структур и массивов. Поскольку в примерах задействуется указательная переменная, то, само собой, требуется некоторое понимание указателей. Случаи могут встретиться более сложные. Не всегда можно сохранить за один раз блок памяти. Чтобы понимать когда можно, когда нет, как раз и нужно понимание указателей и знание, когда выделяется непрерывный блок памяти, а когда выделенное хранится в памяти в разбросанном виде. Но новичкам, как правило, хватает варианта с записью числа в начало файла и последующей записью массива структур. При этом варианты у новичков немного проще, чем показал я. Вся эта тема только вводная в тему записи в бинарные файлы массивов структур. Как я упоминал недавно, развивать пока что не могу, потому что у меня есть определённая нехватка нужных знаний. Тем не менее, надеюсь, что эти примеры сильно помогут вам, потому что даже в 2018г. в интернете сложно найти вот именно вот это вот, когда оно многим, как мне кажется, на самом деле нужно. Могу лишь констатировать, что вам важно разобраться в ходе написания показанных кодов, чтобы задействовать это самостоятельно.
Большое спасибо участникам форума cyberforum: Dr.offset, 0x10, croessmah — за помощь с реализацией примеров. Также спасибо Evg за его ответы в одной из тем того же киберфорума.
Один комментарий на «“Запись в бинарный файл простых массивов структур”»
Добавить комментарий
Случайная книга в электронном формате
пытаюсь таким образом прочесть файл таблицы mySQL которую предварительно пихнул в папку с exe-шником но к сожалению на экран ничего не выводит пользуюсь msvs 2013