Write to a Vector of Type Class from a File

Question

Saving the vector to a file works fine. But I'm looking for a simple way to load the saved data back into the vector.

This is a follow up question to two I asked previously.

1) C++ Trouble Inputting Data into Private Vector (invalid use)

2) Outputting Vector of Type Class

What's a simple way to iterate through the file and push_back() each element?

This is the class:

class Account
{
    private:
        string firstName;
        string lastName;
        string accountPass;
        int accountID;
        float accountBalance;

    public:
        static Account createAccount( int, float, string, string, string ); //creates new account
        int getAccountID() const { return accountID; }
        string getPass() const { return accountPass; }
        string getFirstName() const { return firstName; }
        string getLastName() const { return lastName; }
        float getBalance() const { return accountBalance; }
        friend std::ostream& operator << (std::ostream&, const Account&);
        friend class BankingSystem;

}; //end of class Account


Account Account::createAccount( int ID, float balance, string pass, string first, string last )
{    
    Account a;
    a.accountID = ID;
    a.accountPass = pass;
    a.firstName = first;
    a.lastName = last;
    a.accountBalance = balance;

    return a;

}

std::ostream & operator << (std::ostream & os, const Account & acc)
{
    os << setw(6) << acc.getAccountID();
    os << setw(4) << acc.getPass();
    os << setw(9) << acc.getFirstName();
    os << setw(9) << acc.getLastName();
    os << setw(9) << setprecision(2) << fixed << acc.getBalance();
    return os;
}

Answer 1

If Accounts are the only thing written in your file you can read them all into your vector (or any push_back-able container) with this 1-liner:

std::copy(std::istream_iterator<Account>(file), std::istream_iterator<Account>(), std::back_inserter(vec));

You'll also need an operator>> analogous to the operator<< you already have.

Answer 2

Found the answer in this Question Using vector of user defined class type objects

for me it was solved by using:

while(!inBankSysFile.eof()) 
{
    Account a;
    inBankSysFile >> a.accountID;
    inBankSysFile >> a.accountPass;
    inBankSysFile >> a.firstName;
    inBankSysFile >> a.lastName;
    inBankSysFile >> a.accountBalance;
    accounts_.push_back(a);

}

Answer 3

If you don't have any dynamic memory, you can read and write it to binary pretty easily using ifstream::read and ofstream::write and vector::data. Here's an example:

#include <iostream>
#include <vector>
#include <fstream>

using namespace std;

class Time
{
public:
Time(): hh(0),mm(0),ss(0) {}
Time(int h,int m,int s):hh(h),mm(m),ss(s) {}
int hh,mm,ss;
};

int main()
{
    Time time1(11,22,33);
    Time time2(44,55,66);

    vector<Time> timeList;
    timeList.push_back(time1);
    timeList.push_back(time2);

    vector<Time> timeList2;
    timeList2.resize(2,Time());

    ofstream fout;
    fout.open("test.txt");
    if(fout.is_open())
    {
        // vector.data returns a pointer to the beginning of its stored data
        // 1st param: the location to read data from
        // 2nd param: the amount of bytes to write to the file
        fout.write((const char*)timeList.data(),sizeof(Time)*timeList.size());

        fout.close();
    }

    ifstream fin;
    fin.open("test.txt");
    if(fin.is_open())
    {
        // 1st param: the location to write data to
        // 2nd param: the amount of bytes to read from the file
        // NOTE: make sure you've sized the vector appropriately before writing to it.
        fin.read((char*)timeList2.data(),sizeof(Time)*timeList2.size());

        for(int i=0;i<timeList2.size();++i) {
            cout << timeList2[i].hh << ":" << timeList2[i].mm << ":" << timeList2[i].ss << "\n";
        }

        fin.close();
    }


    return 0;
}

NOTE: Reading/writing objects that use dynamic memory (including objects containing classes that contain dynamic memory, such as std::string), will require additional processing logic to handle reading and writing that data.

NOTE: Beware of variances in structural alignment padding when using the sizes of any objects.