Reading and writing classes with pointers to binary files in c++ - pointers

Question

I've been trying to write some data to a binary file in c++ using fstream and most examples go like this:
#include <fstream>
class Person{
public:
int age;
char name[50];
}
int main(){
Person joe;
joe.age = 50;
strncpy(joe.name, "Joe Jones");
fstream file("filename.dat", ios_base::binary);
file.write((char*)joe, sizeof(joe));
file.close();
}
This works just as expected but the problem arises when I try to write a more complex structure, mainly one with pointers instead of the actual data.
class Person{
public:
int age;
int *friendsAges;
Person(int friends){
friendsAges = new int[friends];
}
}
When I write the data like before
Person joe(10);
/* Initialize rest of joe */
file.write((char*)joe, sizeof(joe));
the resulting file has 8 bytes of data, 4 for the age and 4 for the address of the friendsAges array or so it seems.
How could I go about writing the actual data that is stored in the array? I have also had this problem when my classes have other classes as members such as a Person having a Car or something like that.

Answer 1

For starters, add a method to your class that will perform the file I/O then you can just call it like so:
Person joe();
Person sally();
fstream file("filename.dat", ios_base::out | ios_base::binary);
joe.serialize(file, true);//writes itself to the file being passed in
sally.serialize(file, true); //write another class to file after joe
file.close();
Then later you could read that same file to populate the class instance:
fstream file("filename.dat", ios_base::in | ios_base::binary);
joe.serialize(file, false); //reads from file and fills in info
sally.serialize(file, false); //reads from file too
file.close();
The method in the class would look something like this:
Person::serialize(fstream &fs, bool bWrite)
{
int ages_length;
if (bWrite) {
fs.write(&age, sizeof(age));
ages_length = ...; //you need to know how long the friendsAges array is
fs.write(&ages_length, sizeof(ages_length)); //write the length to file
fs.write(&friendsAges[0], sizeof(int)*ages_length); //write the variable-sized array to file
fs.write(&name[0], sizeof(char)*50); //write a string of length 50 to file
}
else {
fs.read(&age, sizeof(age));
fs.read(&ages_length, sizeof(ages_length)); //read length of array from file
//TODO: you will need to malloc some space for *friendsAges here
fs.read(&friendsAges[0], sizeof(int)*ages_length); //read-in the variable length array
fs.read(&name[0], sizeof(char)*50); //this only works if string length is always fixed at 50
}
}