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

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

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

Чтобы структуру удобно записать враз, нужно знать, сколько памяти занимает объект структуры.

При записи структуры в файл мы копируем биты из памяти в файл. Очень важно взять правильные размеры записываемой сущности. Посмотрим простейший пример:

   //Запись структуры в бинарный файл       clang       Листинг #1
   #include <string.h>
#include <iostream>
#include <fstream>

using namespace std;

struct Worker {
    char Name[256];     //Фамилия сотрудника
    float salary;       //Заработная плата
    int age;            //Возраст рабочего
};

int main()
{
    const char *FName="C:\\MyFiles\\Worker.bin"; //Путь к файлу. Вписывайте свой.
    Worker teacher;     //teacher - Записываемый в файл объект структуры
    Worker w1;          //w1 - читаемый из файл объект структуры

    /*ЗАПОЛНЯЕМ СТРУКТУРУ*/
    strncpy(teacher.Name, "Pupkin", 256);    //в случае работы с Си-строками, нужно копировать строку в строку
    teacher.age = 30;
    teacher.salary = 1523.99;

    /*Записываем структуру в файл*/
    ofstream f1(FName, ios::binary | ios:out);
        f1.write((char*)&teacher, sizeof(teacher));
    f1.close();


    /*Читаем структуру из файла */
    ifstream f2(FName, ios::binary | ios:in);
        f2.read((char*)&w1, sizeof(teacher));
    f2.close();

    /*Вывод данных на экран*/
    cout << w1.Name << '\t' << w1.age << '\t' << w1.salary << '\n';


}

//Запись структуры в бинарный файл clang Листинг #1

#include <string.h>

#include <iostream>

#include <fstream>

using namespace std;

struct Worker {

char Name[256]; //Фамилия сотрудника

float salary; //Заработная плата

int age; //Возраст рабочего

};

int main()

{

const char *FName="C:\\MyFiles\\Worker.bin"; //Путь к файлу. Вписывайте свой.

Worker teacher; //teacher - Записываемый в файл объект структуры

Worker w1; //w1 - читаемый из файл объект структуры

/*ЗАПОЛНЯЕМ СТРУКТУРУ*/

strncpy(teacher.Name, "Pupkin", 256); //в случае работы с Си-строками, нужно копировать строку в строку

teacher.age = 30;

teacher.salary = 1523.99;

/*Записываем структуру в файл*/

ofstream f1(FName, ios::binary | ios:out);

f1.write((char*)&teacher, sizeof(teacher));

f1.close();

/*Читаем структуру из файла */

ifstream f2(FName, ios::binary | ios:in);

f2.read((char*)&w1, sizeof(teacher));

f2.close();

/*Вывод данных на экран*/

cout << w1.Name << '\t' << w1.age << '\t' << w1.salary << '\n';

}

(char*)&w1 —>> Приводим адрес структуры к типу char*. Так устроен механизм записи в бинарный файл, что нужно приводить тип "адрес" к типу char*.
sizeof(teacher) —>> Записываем согласно размеру структуры. Наша структура в данный момент занимает минимум char + float + int байт, максимум — добавку к этому несколько байт, рождённых автоматическими выравниваниями. Посмотрите сами, совпадает ли у вас размер структуры с суммой размеров заявленных внутри структуры типов.

    cout << sizeof(teacher) << " == " << sizeof(teacher.age) + sizeof(teacher.Name) + sizeof(teacher.salary);

1	cout << sizeof(teacher) << " == " << sizeof(teacher.age) + sizeof(teacher.Name) + sizeof(teacher.salary);

Если вы посмотрели, то размеры могли или совпасть, или не совпасть. Если не совпали, то это следствие автоматических выравниваний структуры. Если совпали, попробуйте поменять численные типы (short, double). При записи в файл лучше отключить выравнивание. Делается это с помощью директивы препроцессора pragma pack

   #pragma pack(push, 1)
struct Worker {
    int age;            //Возраст рабочего
    double salary;       //Заработная плата
    char Name[256];     //Фамилия сотрудника
};
#pragma pack (pop)

#pragma pack(push, 1)

struct Worker {

int age; //Возраст рабочего

double salary; //Заработная плата

char Name[256]; //Фамилия сотрудника

};

#pragma pack (pop)

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

Размер структуры можно узнавать как минимум двумя способами: применять sizeof к объекту структуры, как было проделано в листинге #1, применять sizeof к имени структуры. В зависимости от ситуации удобным может оказаться или первый, или второй вариант. Предположим, например, что в нашем коде не непосредственно структура, а указатель на структуру, тогда sizeof(teacher) вычисляла бы размер указательной переменной, но не размер структуры:

            Worker *teacher = new Worker;   //указательная переменная teacher
                  sizeof(teacher); //даёт не размер структуры, а размер указателя
            delete teacher;

Worker *teacher = new Worker; //указательная переменная teacher

sizeof(teacher); //даёт не размер структуры, а размер указателя

delete teacher;

Поскольку вариант из листинга #1 дал слабину (размер указательной переменной нам при записи в файл явно не нужен сейчас), мы используем в таком случае sizeof к названию структуры:

//Запись структуры в бинарный файл, если на структуру указывает указатель clang Листинг #2

#include <string.h>
#include <iostream>
#include <fstream>

using namespace std;

#pragma pack(push, 1)
struct Worker {
    int age;            //Возраст рабочего
    double salary;       //Заработная плата
    char Name[256];     //Фамилия сотрудника
};
#pragma pack (pop)

int main()
{
    const char *FName="C:\\MyFiles\\Worker.bin"; //Путь к файлу. Вписывайте свой.
    Worker *teacher;     //teacher - Записываемый в файл объект структуры
    Worker w1;          //w1 - читаемый из файл объект структуры

    teacher = new Worker;
    /*ЗАПОЛНЯЕМ СТРУКТУРУ*/
    strncpy(teacher->Name, "Pupkin", 256);    //в случае работы с Си-строками, нужно копировать строку в строку
    teacher->age = 30;
    teacher->salary = 1523.99;

    /*Записываем структуру в файл*/
    ofstream f1(FName, ios::binary | ios:out);
        f1.write((char*)teacher, sizeof(Worker));       //<--- Эта строчка изменилась в двух местах!!!
    f1.close();
    delete teacher;


    /*Читаем структуру из файла */
    ifstream f2(FName, ios::binary | ios:in);
        f2.read((char*)&w1, sizeof(Worker));
    f2.close();

    /*Вывод данных на экран*/
    cout << w1.Name << '\t' << w1.age << '\t' << w1.salary << '\n';



}

#include <string.h>

#include <iostream>

#include <fstream>

using namespace std;

#pragma pack(push, 1)

struct Worker {

int age; //Возраст рабочего

double salary; //Заработная плата

char Name[256]; //Фамилия сотрудника

};

#pragma pack (pop)

int main()

{

const char *FName="C:\\MyFiles\\Worker.bin"; //Путь к файлу. Вписывайте свой.

Worker *teacher; //teacher - Записываемый в файл объект структуры

Worker w1; //w1 - читаемый из файл объект структуры

teacher = new Worker;

/*ЗАПОЛНЯЕМ СТРУКТУРУ*/

strncpy(teacher->Name, "Pupkin", 256); //в случае работы с Си-строками, нужно копировать строку в строку

teacher->age = 30;

teacher->salary = 1523.99;

/*Записываем структуру в файл*/

ofstream f1(FName, ios::binary | ios:out);

f1.write((char*)teacher, sizeof(Worker)); //<--- Эта строчка изменилась в двух местах!!!

f1.close();

delete teacher;

/*Читаем структуру из файла */

ifstream f2(FName, ios::binary | ios:in);

f2.read((char*)&w1, sizeof(Worker));

f2.close();

/*Вывод данных на экран*/

cout << w1.Name << '\t' << w1.age << '\t' << w1.salary << '\n';

}

Кроме того, что мы немного иначе подсмотрели размер, при приведении типа у нас не задействовался знак & В данном случае не имеет смысла приводить адрес к адресу, это даже вредит (можете попробовать вставить убранный символ), поэтому мы для приведения задействуем непосредственно название указательной переменной, таким образом мы приводим адрес указательной переменной к типу char*. Такая вот разница есть при записи в бинарный файл обычных типов, с опорой на указательную переменную. Просто понять нужно, что указатель — это адрес, если адрес, то получится взятие адреса какого-то адреса и этот адрес адреса будет приводится, но то другая сущность. Т. е. если имеется адрес (указательная переменная), то записываем, опираясь на название указательной переменной, если не имеется адреса, то записываем, подбирая адрес у переменной/объекта.

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

#include <string.h>
#include <iostream>
#include <fstream>

using namespace std;

#pragma pack(push, 1)
struct Worker {
    int age;            //Возраст рабочего
    double salary;       //Заработная плата
    char *Name;
};
#pragma pack (pop)

int main()
{
    const char *FName="C:\\MyFiles\\Worker.bin"; //Путь к файлу. Вписывайте свой.
    Worker teacher;     //teacher - Записываемый в файл объект структтуры
    Worker w1;          //w1 - читаемый из файл объект структуры

    teacher.Name = new char[256];
    /*ЗАПОЛНЯЕМ СТРУКТУРУ*/
    strncpy(teacher.Name, "Pupkin", 256);    //в случае работы с Си-строками, нужно копировать строку в строку
    teacher.age = 30;
    teacher.salary = 1523.99;


    /*Записываем структуру в файл*/
    ofstream f1(FName, ios::binary | ios:out);
        f1.write((char*)&(teacher.salary), sizeof(teacher.salary));
        f1.write((char*)&(teacher.age), sizeof(teacher.age));
        f1.write((char*)(teacher.Name), sizeof(teacher.Name) * 256);    //Из-за указательной переменной пришлось делать поэлементную запись
    f1.close();
    delete []teacher.Name;

{
    /*Читаем структуру из файла */
    w1.Name = new char[256];
    ifstream f2(FName, ios::binary | ios:in);
        f2.read((char*)&(w1.salary), sizeof(w1.salary));
        f2.read((char*)&(w1.age), sizeof(w1.age));
        f2.read((char*)(w1.Name), sizeof(w1.Name) * 256);   //Из-за указательной переменной пришлось делать поэлементную запись
    f2.close();


    /*Вывод данных на экран*/
    cout << w1.Name << '\t' << w1.age << '\t' << w1.salary << '\n';
}
    delete []w1.Name;


}

#include <string.h>

#include <iostream>

#include <fstream>

using namespace std;

#pragma pack(push, 1)

struct Worker {

int age; //Возраст рабочего

double salary; //Заработная плата

char *Name;

};

#pragma pack (pop)

int main()

{

const char *FName="C:\\MyFiles\\Worker.bin"; //Путь к файлу. Вписывайте свой.

Worker teacher; //teacher - Записываемый в файл объект структтуры

Worker w1; //w1 - читаемый из файл объект структуры

teacher.Name = new char[256];

/*ЗАПОЛНЯЕМ СТРУКТУРУ*/

strncpy(teacher.Name, "Pupkin", 256); //в случае работы с Си-строками, нужно копировать строку в строку

teacher.age = 30;

teacher.salary = 1523.99;

/*Записываем структуру в файл*/

ofstream f1(FName, ios::binary | ios:out);

f1.write((char*)&(teacher.salary), sizeof(teacher.salary));

f1.write((char*)&(teacher.age), sizeof(teacher.age));

f1.write((char*)(teacher.Name), sizeof(teacher.Name) * 256); //Из-за указательной переменной пришлось делать поэлементную запись

f1.close();

delete []teacher.Name;

{

/*Читаем структуру из файла */

w1.Name = new char[256];

ifstream f2(FName, ios::binary | ios:in);

f2.read((char*)&(w1.salary), sizeof(w1.salary));

f2.read((char*)&(w1.age), sizeof(w1.age));

f2.read((char*)(w1.Name), sizeof(w1.Name) * 256); //Из-за указательной переменной пришлось делать поэлементную запись

f2.close();

/*Вывод данных на экран*/

cout << w1.Name << '\t' << w1.age << '\t' << w1.salary << '\n';

}

delete []w1.Name;

}

В нашем случае указательная переменная относительно простая: она представляет собой эквивалент массива. Возможны ситуации, где указатели разбросаны по памяти и собраны в какую-то сущность. Например, это может быть массив указателей (int **arr). В таком случае всё ещё сложнее. Кроме поэлементной обработки внутренних структуре типов может быть придётся обходить те структуры, которые представляют собой указательные переменные. В идеале, конечно, избежать указателей.

(char*)&X —> Для новичков неудобная, непонятная запись. Читать ее нужно справа налево. Адрес структуры X приводится к типу указатель на char. Это необходимо, чтобы сообщить методу write (read) адрес структуры в нужном ему виде. Внимательно прочитайте справа-налево, единственное: &X = адрес структуры X, и имейте ввиду, что такой вид обратного чтения при работе с указателями бывает часто удобен.

Постарайтесь не запутаться и не взять адрес у адреса, если вам нужен просто адрес

Постарайтесь избежать указателей, если это возможно

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

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

Статья полностью переписана 27.03.2018

Рубрика: Базовые знания, level "HelloWorld", Структуры, Файлы

admin:

09.04.2015 в 2:48 пп

Выше сказано про другое. То о чем говорилось тогда я исправил тогда.
На строку выделено 255 символов.
В строку вводится строка
Последний символ в строке — признак окончания строки
За признаком окончания строки все что угодно. Это мусор.

Добавить строчку

strcpy(X.buf,"ci-plus-plus-snachala.ru"); //Записали значение в поле buf
    for (int i=strlen(X.buf);i<255;i++) X.buf[i]='\0'; //Вот эту

1 2	strcpy(X.buf,"ci-plus-plus-snachala.ru"); //Записали значение в поле buf for (int i=strlen(X.buf);i<255;i++) X.buf[i]='\0'; //Вот эту

и мусора не будет видно в файле.

Ответить

RomixERR:

13.05.2015 в 4:02 пп

А теперь я объясню подробнейшем образом что такое (char*)&X .

#include <iostream>
#include <fstream>
#include <ios>
#include <conio.h>
using namespace std;
struct vol
{
int A;
int B;
};

void main()
{
vol X; //обьявили переменную Х типа структуры vol
X.A=82; //определили (задали поля структ. переменной)
X.B=111;

ofstream FILE("1.txt",ios::binary); //создаём обьект класса ofstream при помощи конструктора

// для записи в файл используется метод экземпляра класса .write - первый его аргумент требует char * - тоесть указатель типа чар на переменную типа чар.
// если бы у нас был массив char X[] то такой указатель получить было-бы просто: X - это и есть указатель на первый элемент массива, идентично &X[0]
// а у нас структура, по этому нужно сделать преобразование типов указателей. Если писать подробно, то:

vol * UkVol; //обьявляем переменную типа "указатель vol"
char * UkChar; //обьявляем переменную типа "указатель char"

UkVol = &X; //присваиваем ссылку на X - указателю
// далее следует сделать приведение типов
UkChar = reinterpret_cast<char *>(UkVol);
// можно и так, но это устаревшая форма записи:
//UkChar=(char *)UkVol;
FILE.write(UkChar,sizeof X); //Записываем наконец-то в файл используя в методе те аргументы, которые требуются
FILE.close();
//в папке проекта создастся филе с именем 1.txt - там будет строчка "R o ".
//открыть структуру можно аналогично, используя метод .read

}

#include <ios>

#include <conio.h>

struct vol

int A;

int B;

void main()

vol X; //обьявили переменную Х типа структуры vol

X.A=82; //определили (задали поля структ. переменной)

X.B=111;

ofstream FILE("1.txt",ios::binary); //создаём обьект класса ofstream при помощи конструктора

// для записи в файл используется метод экземпляра класса .write - первый его аргумент требует char * - тоесть указатель типа чар на переменную типа чар.

// если бы у нас был массив char X[] то такой указатель получить было-бы просто: X - это и есть указатель на первый элемент массива, идентично &X[0]

// а у нас структура, по этому нужно сделать преобразование типов указателей. Если писать подробно, то:

vol * UkVol; //обьявляем переменную типа "указатель vol"

char * UkChar; //обьявляем переменную типа "указатель char"

UkVol = &X; //присваиваем ссылку на X - указателю

// далее следует сделать приведение типов

UkChar = reinterpret_cast<char *>(UkVol);

// можно и так, но это устаревшая форма записи:

//UkChar=(char *)UkVol;

FILE.write(UkChar,sizeof X); //Записываем наконец-то в файл используя в методе те аргументы, которые требуются

FILE.close();

//в папке проекта создастся филе с именем 1.txt - там будет строчка "R o ".

//открыть структуру можно аналогично, используя метод .read

Действительно, (char*)&X не удобная и устаревшая запись. Следует писать reinterpret_cast&X

admin:

13.05.2015 в 5:27 пп

reinterpret_cast(UkVol); гораздо неудобнее и выглядит уродливо.
То не устаревшая форма записи, то форма записи в стиле Си. Да, считается, что преобразования делать лучше не в стиле Си.
А еще лучше использовать std::string и не использовать указатели

Ответить