Re: [Boost-users] [serialization, 1_33_0] Correct usage and implementation for serializable objects without default constructors

From: Robert Ramey (ramey_at_[hidden])
Date: 2005-09-07 11:46:31

signature
In this example, we have a class A that doesn't have a default constructor. 
An int is needed by the constructor, which is stored in the i member 
variable.  load/save_construct_data are used to un/serialize the i member, 
while the serialize member is used for all other members.

Looking at this test, I see a couple of behaviors that puzzle me.

-) Saving the 'a' instance in the save() function doesn't end up calling 
save_construct_data.  This leaves a serialized version of A which lacks the 
'i' member.  This makes it impossible to fully restore the 'a' instance.  It 
seems problematic to me that save_construct_data isn't called in this case.

I just re-ran test_non_default_ctor.  I ran under the VC 7.1 debugger and 
inserted traps inside both save_construct_data and load_construct_data. II 
verified that save_construct_data and load_construct_data are being invoked 
exactly as they are intended.  I see no problem here.

 In my planned usage, I'd like to fully serialize all members, regardless if 
the objects are serialized directly or through pointers.  I cannot see how 
to do this without serializing the members needed to reconstruct the object 
in both serialize and save_construct_data, even if some members will end up 
serialized twice when an object is stored through a pointer.

If the members are not pointers, the constructor is never called. so the 
parameters set by the constructor are not needed.  save_load_contruct_data 
is only called when its necessary to create a new object.

What's the proper way to serialize all members of a class without a default 
constructor so that it gets fully serialized regardless how the objects are 
managed?

Exactly as described in the manual and illustrated by the example 
test_non_default_ctor.

-) When restoring the 'a' instance within load(), in order to restore it, we 
first create another 'a' instance (with a different constructor argument), 
then restore the other members within, leaving untouched the 'i' member. 
Assuming I'd like to be able to serialize and unserialize completely objects 
that do not have a default constructor, I'm wondering how I can fully 
restore an object that doesn't have a default constructor.

All you have to do is define save_construct_data and load_construct_data for 
all types which don't have a default constructor.  The library takes care of 
everything else.

I've looked for some other mechanism relying on a copy constructor and 
something along the lines of load_construct_data, but I haven't found any.

Somehow I'm thinking you're looking for the wrong thing.  I wonder if you're 
not underestimating what the library does for you.  As I said,  you, only 
need to define save/load_construct_data for those types which don't have a 
default constructor - there is nothing else required to do.

Robert Ramey