Reconstructing a vector saved in a binary file..

I've stumbled on this little example: vector::reserve - C++ Reference

What I'm trying to do is stick a bunch of employee objects in a vector, save it to a file, and load the file and use the vector next time I open the program, a database of sorts.

Code:

---


void save_data()
{
    ofstream employee_data;
    employee_data.open("employee_data.bin", ios::binary);
    if (employee_data.is_open())
    {
        cout << "File successfully opened and initialized." << endl;
        if(!employees.empty())
        {
            employee_data.write(reinterpret_cast<char*>&employees[0], employees.size() * sizeof(employee));
            cout << "Data successfully written to the file." << endl;
        }
        else
        {
            cout << "That vector is empty bro...." << endl;
        }
    }
    else
    {
        cout << "This didn't work noob!" << endl;
    }
}

void get_data()
{
    ifstream employee_data;
    employee_data.open("employee_data.bin", ios::binary);
    if(employee_data.is_open())
    {
        //start copying data to memory
    }
    else
    {
        //something went wrong, probably can't find file, or doesn't exist
    }
}

---

I'm not 100% sure how to go about copying the data from the file so that I can use the data in memory like I would any other vector.

What do your employee objects look like data-members-wise? Unless they are strictly POD you are going to have issues writting/reading to/from a file like you are attempting.

Like this?

Code:

---


class employee
{
public:
        employee(std::string, float);
        const std::string& get_name();
        const float& get_payrate();
        const std::string& get_gender();
        const std::string& get_startdate();
        const std::string& get_enddate();

        void set_name(std::string);
        void set_payrate(float);
        void set_gender(std::string);
        void set_startdate(std::string);
        void set_enddate(std::string);
private:
        std::string name;
        float payrate;
        std::string gender;
        std::string startdate;
        std::string enddate;
        bool active;
};

---

Serialization is what you are looking for (Serialization).

Do I really need to install boost to do serialization, isn't there a standard?

You do not "have" to install boost to do serialization, but no there is no "standard". To successfully read and write information to a binary file the data must be read exactly as it was written. The problem with std::string is that every string can contain a different number of characters. You need someway of knowing how many bytes this string contains when written so you can read back the same number of bytes.

Have you considered just using a text file instead of the binary file?

Jim

There is no standard one. There are also other libraries in the link I posted.

Well, I do not want to use a text file because ultimately I want my code to be a bit more re-usable.

And honestly boost seems to be the best thing for this, as it is minimally intrusive, as I've been reading. I also don't really want the files to be changed outside of the application.

Quote:

---

Originally Posted by Shamino

Well, I do not want to use a text file because ultimately I want my code to be a bit more re-usable.

---

That is a rather (ahem) novel excuse for wanting to write a binary file rather than a text file.

If you write a text file the, in practice, there is a high likelihood that the contents can be read correctly when the code is rebuilt using another compiler, or ported to another operating system. Conversely, if you write a binary file, there is a high likelihood that the contents can not be read correctly unless you stick only to one compiler.

If you care about reusability, the easiest approach is to use a text file. It is possible to do it with a binary file, but significantly more effort (for example, rigorously defining a protocol that describes what the content of a binary file means) to do so.

Writing binary files does not prevent files being changed outside your application. It can actually increase the impact of data corruption (for example, if a problem occurs with your hard drive) unless the binary format is designed with fault tolerance in mind. If someone is determined to change your data files, they will work out a way.

I agree with grumpy; text is a more robust form of serialization.

However, it's also generally more work, for you and the executable. So two valid excuses not to do so would be:
- I don't consider it necessary because of the scope of the task.
- There is some highly significant performance aspect involved.

The nature of STL containers partially nullifies the second excuse, because the most efficient option -- writing a whole vector object straight to a file -- is not feasible*. Instead, you have to write the contents of the vector to a file. In which case, using text is only another intermediate step.

* neither is writing an employee object, or any kind of object AFAIK. What you should do is write an employee.toString method to serialize the data members to text, then iterate thru the vector, call that for each employee, and write each string to the file using some delimiter between records (eg, a double '\n'). You then write an extra constructor that takes a single string (formatted the way toString does) for de-serialization, and use that when you load the vector from a file.

Quote:

---

Originally Posted by MK27

I agree with grumpy; text is a more robust form of serialization.

However, it's also generally more work, for you and the executable. So two valid excuses not to do so would be:
- I don't consider it necessary because of the scope of the task.
- There is some highly significant performance aspect involved.

The nature of STL containers partially nullifies the second excuse, because the most efficient option -- writing a whole vector object straight to a file -- is not feasible*. Instead, you have to write the contents of the vector to a file. In which case, using text is only another intermediate step.

* neither is writing an employee object, or any kind of object AFAIK. What you should do is write an employee.toString method to serialize the data members to text, then iterate thru the vector, call that for each employee, and write each string to the file using some delimiter between records (eg, a double '\n'). You then write an extra constructor that takes a single string (formatted the way toString does) for de-serialization, and use that when you load the vector from a file.

---

This sounds way more fun to do than all of the other suggestions. I can just figure a way to send a stringstream to the ofstream, and create the stringstream from the data members in the employee file, which is basically a bunch of strings anyways.