Hello!
Suppose I have a class that contains only public members
of builtin types and a default constructor. Because of the
default constructor it is no longer an aggregate and therefore
no longer POD, according to my understanding of
http://www.fnal.gov/docs/working-gro...x/doc/POD.html
I need to be able to serialize this class to/from a binary file
and read() and write() look like the easiest way. But if I
understand correctly, this is *not* guaranteed to work because
the class is non-POD, right?
Arrays of this class (let's call it 'data') need to be
stored/restored to/from a binary file in a templated class
datafile<data>. The class 'datafile' is a part of a library,
while 'data' is supplied by the library user who wants to store
arrays of 'data' into the file represented by 'datafile<data> '.
How would you go around this? I could remove the default
ctor and add a public init() method, which would make it POD,
but what happens if the user tries her 'data' class that
contains non-POD members, therefore making it non-POD.
Perhaps I should require that the data class supplies
some methods like serialize_to_by tes() and restore_from_by tes()?
That would be easy for the library, but annoying for users
who would then instead of simple
class data {
public:
int myint;
double mydouble;
long int mylong;
};
have to use
class data {
public:
int myint;
double mydouble;
long int mylong;
void serialize_to_by tes(...) {
// ... quite a few lines of code
}
void restore_from_by tes(...) {
// ... quite a few lines of code
}
};
Or perhaps storing/reading classes like that is safe even
though they contain members that are not strictly POD because
they have constructors? I am assuming no members contain
static data, there are also no pointers or pointers-to-members
involved.
TIA,
- J.
