#include <iostream>
#include <fstream>
#include <date>
 
using namespace std;
 
int main()
{
string a;
string n;
int b;
int aNum;
int date;
 
 
ofstream jun("file.txt", ios::app | ios::ate ); 
 
 
if (jun.fail ())
{
cout << "Error opening file, program closing" << endl;
exit(1);
}
 
cout << "Please enter a name" << endl;
cin >> n;
cout << "Please enter an age" << endl;
cin >> a;
cout << "Please enter an expiry date" << endl;
cin >> date;
 
 
srand ( time(NULL) ); // this seeds the random number so it will not be dulplicated
 
aNum = rand() % 999 + 1000;/* The random number generator here is producing a
 
random number between 0 and 999 and then will make the
 
random value be within the range of +1000 - +1999 as it is
 
addingg 1000. Accounts with numbers begining with 1 will be 
 
Junior accounts and accounts with numbers beggining 
 
with 2 will be Full accounts */
 
 
 
b = 0; //default balance will be nil or 0
 
jun << n << " " << aNum << " " << b << " " << a << " " << date << endl;//output to file
 
jun.close();
 
 
 
 
}

fstream f(filename,ios::in|ios::out|ios::ate);

John 42 15.69
Bill 34 17.89

struct MemberRecord
{
    std::string name;
    int age;
    float balance;
};

MemberRecord mem;
ifstream fin("myfile.txt");
fin >> mem.name >> mem.age >> mem.balance;
myvector.push_back(mem);

ifstream& operator>>(ifstream& fin,MemberRecord& mem)
{
    fin >> mem.name >> mem.age >> mem.balance;
}
 
//... in some other function:
fin >> mem;
myvector.push_back(mem);

ifstream& operator>>(ifstream& fin,MemberRecord& mem)
{
    fin >> mem.name >> mem.age >> mem.balance;
    return fin;
}

class Record
{
public:
    Record(): age(0) {}
 
    explicit Record(const char* pline);
    explicit Record(const string& line);
    Record(const char* pname, int age);
    Record(const string& newname, int newage);
 
    const string& getName() const
    {
        return name;
    }
    const string& setName(const char* pname)
    {
        if (pname)
            name = pname;
        return name;
    }
    const string& setName(const string& newname)
    {
        return name = newname;
    }
    int getAge() const { return age; }
    int setAge(int newage)
    {
        if (newage >= 0 && newage < 150)
            age = newage;
        return age;
    }
    bool parse(const string& line);
    string toString() const;
private:
    static char delim;
    string name;
    int age;
};
 
ostream& operator << (ostream& os, const Record& r)
{
    os << r.getName() << " " << r.getAge();
    return os;
}
 
char Record::delim = '|';
 
Record::Record(const char* pline):age(0)
{
    parse(pline);
}
 
Record::Record(const string& line):age(0)
{
    parse(line);
}
 
Record::Record(const char* newname, int newage):age(0)
{
    setName(newname);
    setAge(newage);
}
Record::Record(const string& newname, int newage):age(0)
{
    setName(newname);
    setAge(newage);
}
 
bool Record::parse(const string& line)
{
    istringstream ins(line);
    char namebuf[64];
    if (!ins.get(namebuf,sizeof namebuf,delim))
        return false;
    ins.ignore(1);
    int age;
    if (ins >> age)
    {
        name = namebuf;
        setAge(age);
        return true;
    }
    else return false;
}
 
string Record::toString() const
{
    ostringstream ost;
    ost << name << delim << age;
    return ost.str();
}
 
class PlainDb
{
public:
 
    int load(const char* fname);
    int load(const string& fname)
    {
        return load(fname.c_str());
    }
    int save(const char* fname);
    int save(const string& fname)
    {
        return save(fname.c_str());
    }
    Record& operator [](int i)
    {
        return i >= 0 && i < size()? db[i]: dummy;
    }
    int findByName(const char* pname)
    {
        if (pname)
        {    
            string sname(pname);
            for (int i = 0; i < size(); ++i)
                if (db[i].getName() == sname)
                    return i;
        }
        return -1;
    }
    int findByName(const string& sname)
    {
        return findByName(sname.c_str());
    }
    int size() const { return db.size(); }
private:
    static Record dummy;
    vector<Record> db;
};
 
Record PlainDb::dummy("Unknown",0);
 
int PlainDb::load(const char* fname)
{
    int nrecs = -1;
    if (fname)
    {
        ifstream f(fname);
        if (f)
        {
            Record r;
            string line;
            for (nrecs = 0; getline(f,line); ++nrecs)
            {
                if (!r.parse(line))
                    return -1;
                db.push_back(r);
            }
        }
    }
    return nrecs;
}
 
int PlainDb::save(const char* fname)
{
    int nrecs = -1;
    if (fname)
    {
        ofstream f(fname,ios::ate|ios::trunc);
        for (nrecs = 0; nrecs < size(); ++nrecs)
        {
            f << db[nrecs].toString() << "\n";
            if (f.bad())
                return nrecs?-nrecs:-1;
        }
        f.flush();
    }
    return nrecs;
}
 
void dbTest(const string& dbname)
{
    PlainDb db;
 
    if (db.load(dbname) <= 0)
        return;
 
    int i = db.findByName("Jesus");
    if (i >= 0)
    {
        db[i].setName("Maria");
        db[i].setAge(18);
 
        db.save(dbname);
    }
}