Re: [Boost-users] boost::serialization - prevent object creation whenloading a pointer

12 Dec 2007


      How about the following:

template<class Archive>
 void save(Archive& ar, const unsigned int version) const {
      ar <<  _m;
       cout << "serialise A, _m = " << (unsigned long)_m << endl;
}
void save(Archive& ar, const unsigned int version) const {
    base * t;
     ar >> t; // deserialize to a temporary
    // modify _m according to t
     cout << "serialise A, _m = " << (unsigned long)_m << endl;
    delete t;
}

Robert Ramey


Darryl Lawson wrote:
...
I realise that what I am doing is no doubt an unconventional usage of
boost::serialization, but I wonder if any one has done a similar thing
before.
I wish to serialize a derived class through a baseclass pointer, but
on deserilize I do not want the object to be created (I do not want
memory allocated) - as the object will have all ready been created.
An example, hopefully showing what I mean, is given at the end. The
program will output something like,
construct A, _m = 155640808
   serialise A, _m = 155640808
   construct A, _m = 155649400
   serialise A, _m = 155649808
But essentially I want the program to output something lke,
construct A, _m = 155640808
   serialise A, _m = 155640808
   construct A, _m = 155649400
   serialise A, _m = 155649400
i.e. the second lot of construct A/serialise A will have the same
address for _m.
The reason why I need this behaviour, is that only a sub-set of the
derived class will be seriliazed, with the other parts of the class
intialised differently depending on the session, and the
initialisation
of the class is always done _before_ deserialisation.
Is there anyway to get this behaviour from the boost::serialization
library?
Many thanks,
Darryl
Example
-------
#include <fstream>
#include 
#include 
#include 
using namespace std;
struct base {
   virtual ~base() {}
   template<class Archive>
   void serialize(Archive& ar, const unsigned int version) {}
};
struct derived : public base {
   derived() : base(), _value(0) {}
template<class Archive>
   void serialize(Archive& ar, const unsigned int version) {
       boost::serialization::void_cast_register();
       ar & _value;
   }
int _value;
};
BOOST_CLASS_EXPORT(derived);
struct A {
   A() {
       _m = new derived;
       cout << "construct A, _m = " << (unsigned long)_m << endl;
   }
template<class Archive>
   void serialize(Archive& ar, const unsigned int version) {
       // On deserialize this will create a new object, but I do not
want it to,
       // rather I would like it to deserialize into the all ready
       created // object.
       ar & _m;
       cout << "serialise A, _m = " << (unsigned long)_m << endl;
   }
base* _m;
};
void save(const A& a, const char* filename) {
   std::ofstream ofs(filename);
   boost::archive::text_oarchive oa(ofs);
   oa << a;
}
void load(A& a, const char* filename) {
   std::ifstream ifs(filename);
   boost::archive::text_iarchive ia(ifs);
   ia >> a;
}
int main(int argc, char* argv[]) {
   A a;
   save(a, "archive.txt");
   A new_a;
   load(new_a, "archive.txt");
   return 0;
}