Hi,

this question has been asked thousand of times and I still can not see a detailed answer. How can I deserialize a class with no default constructor.
The usual response is to point to this documentation http://www.boost.org/doc/libs/1_35_0/libs/serialization/doc/serialization.html#constructors . I read the documentation many time and I can not figure out what does it mean and how it can be used.

Does any body has a working small example where this is effectively used?

Ideally, I am looking for something like the following, I am willing to accept other options, like making a2 a pointer, etc.

int main(){
{
     A a( ... ); // proper construction syntax
     std::ofstream ofs("A.xml");
     boost::archive::xml_oarchive oa(ofs);
     a & BOOST_SERIALIZATION_NVP(a);
}
{
     std::ifstream ifs("A.xml");
     boost::archive::xml_iarchive ia(ifs);
     A a2(ia); // construct from iarchive or some other intermediate class
     {
         a2 & BOOST_SERIALIZATION_NVP(a2); //data can still be loaded in existing object (as usual)
     }
}
return 0;
}

Even if I want to implement my own reading of the xml_iarchive inside the constructor of A, it looks like I need to access the nested elements of the class before accessing to the level of the class (I am thinking in xml terms here).

This is where I am stuck, the syntax above forces me to define

A::A(boost::archive::xml_iarchive& ia){ ... }

If all members are default constructible I can do:

   A::A(boost::archive::xml_iarchive& ia){
     ia & BOOST_SERIALIZATION_NVP(*this);
   }
(yes, the solution in intrusive but the at least I avoid default constructor at all cost)

but if one of the member is not default constructible (and I can modify that class) I should be able to do something like,

   A::A(boost::archive::xml_iarchive& ia) : member1( ...ia?... ){
      // ia & BOOST_SERIALIZATION_NVP(member2); // not possible because the archive is still waiting for class of type A to be read
   }

which has two problems, 1) I need to access the elements of the archive (e.g. member2 before A is really handled by boost.serialization) 2.a) for member1 it regresses the problem to the member1 type, which is fine because all this objects will at some point be composed only from build-in "default constructible" types 2.b) if I have no way to modify member1 and it is not default constructible then I can't continue but that is also fine because that means that member1 was not serializable anyway.

The real problem is 1). because if I have access to all the classes I will reach a point in which I have to read a built-in class from the iarchive, but I have have access to those nested elements directly, at least not with the documented interface.

Thanks,
Alfredo