Serialize C++ object with dynamically allocated attributes - c++

Question

I need to serialize an instance of a class to a binary (or some other non-readable) file. The problem is:
The attributes are pointers, which means I need to serialize the heap memory.
Some of the pointers are function pointers.
I've partially managed to deal with the first one. Still, to me all this code looks unsafe and confusing, and I'm still looking for a better way.
Entity.h
#include <vector>
#include <string>
using namespace std;
class Entity
{
private:
vector<int> field_1 = {1, 23, 356, 4787, 5};
vector<double> field_2 = {1.1, 75.757, 0, 45612};
public:
void serialize(const string& filename);
void deserialize(const string& filename);
void show();
void clear();
};
Entity.cpp
#include <iostream>
#include <fstream>
#include "Entity.h"
void Entity::serialize(const string& filename) {
fstream file(filename, ios::binary | ios::out);
if (!file.is_open()) {
cout << "Failed to open the file" << endl;
return;
}
size_t size = field_1.size();
file.write((const char*)&size, sizeof size); // First I write the size of the array
file.write((const char*)field_1.data(), sizeof *field_1.data() * size); // The array itself
size = field_2.size();
file.write((const char*)&size, sizeof size);
file.write((const char*)field_2.data(), sizeof *field_2.data() * size);
file.close();
}
void Entity::deserialize(const string& filename) {
fstream file(filename, ios::binary | ios::in);
if (!file.is_open()) {
cout << "Failed to open the file" << endl;
return;
}
size_t size;
file.read((char*)&size, sizeof size); // Read the size
field_1.resize(size);
file.read((char*)field_1.data(), sizeof *field_1.data() * size); // Read the data
file.read((char*)&size, sizeof size);
field_2.resize(size);
file.read((char*)field_2.data(), sizeof *field_2.data() * size);
file.close();
}
void Entity::show() {
if (field_1.size()) for (auto i : field_1) cout << i << ' ';
else cout << "field_1 is empty";
cout << endl;
if (field_2.size()) for (auto i : field_2) cout << i << ' ';
else cout << "field_2 is empty";
cout << endl;
}
void Entity::clear() {
field_1.clear();
field_2.clear();
}
Main.cpp
#include "Entity.h"
int main() {
Entity e;
e.show();
e.serialize("data.bin");
e.clear();
e.show();
e.deserialize("data.bin");
e.show();
}
The output
1 23 356 4787 5
1.1 75.757 0 45612
field_1 is empty
field_2 is empty
1 23 356 4787 5
1.1 75.757 0 45612
As the amount of attributes grows, this code grows significantly. Besides, I have to watch the order of reading the data, which may accidentally lead to messing all the data.
As for the second point, I haven't come up with any ideas yet.
What is the best way to serialize an instance of a class with pointer attributes?

Answer 1

As #fredrik points out, there are plenty of libraries to do this for you, or to help you do it. Use them. Or if you won't ..
You serialize what an object represents, not how it is held in memory at any specific time. So if you have a pointer p to an object of type T, you serialize *p -- the thing it points at. When deserializing, you need to know enough about the structure that you're deserializing to, that you allocate memory for a T -- that recreates a pointer -- and then deserialize to the fresh object of type T.
As an example, consider serializing this type:
struct T { int i; char *s; };
(terrible structure; use better names and don't use raw char pointers). To serialize an object o of this type, write out the serialization of the value of o.i, and then .. well, what does o.s represent? In the vast majority of systems, there's no point in writing out "the string s was at memory address 0xffe8deadbeef". So you write out what it represents. Is it a string with only ASCII characters? You could write its length, followed by the string it points to. You could serialize this specific structure with a single call to printf("%d;%d;%s;",...). Deserializing is left as an exercise.
You serialize what an function represents, not how it is held in memory. Function pointers are the same: there is no point in writing down "the function at address -151" because in the vast majority of systems, that address will be different the next time you start the computer, run the program, whatever. Write out something that allows you to reconstruct what the function pointer was. If you are hanging on to std::function objects or lambda's, then you are likely SOL if you have no idea what the function is supposed to be doing or why it's there.