C ++ Boost序列化，构造函数和数据复制

Question

I am trying to understand how the serialization by boost library works, and I want to just ensure that I think correctly.

If I save object (I have only pointer to this object) and then try to load it, the sequence is following:

1. Calling the constructor of this object.
2. Copying the data.

The thing is if constructor use the static members (for example some counters) of the class, it gives me misleading information about loaded objects. I have object's ID based on static counter and (after loading) object's ID printed by constructor to console is incorrect. It seems to make no harm to my program, because after calling constructor all works great. Even the destructor prints me correct ID of object.

Am I right about this sequence? Or maybe some other "magic" is happening here?

Answer 1

If I save object (I have only pointer to this object) and then try to load it, > the sequence is following:

1. Calling the constructor of this object.
2. Copying the data.

You are right. When boost serialization library loads the data, first the default constructor is called, and then data are copied as long as you use serialize() member function template.

Here is an example. You can also see execution result: http://melpon.org/wandbox/permlink/xlzdnK0UnZo48Ms2

#include <fstream>
#include <string>
#include <cassert>
#include <iostream>

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

class Person {
public:
    Person():id_(id_master_++) {
        std::cout << "Person() id = " << id_ << " and id_master_ is incremented to " << id_master_ <<std::endl;
    };
    ~Person() {
        std::cout << "~Person() id = " << id_ << std::endl;
    }
    Person(std::string const& name, int age)
        :id_(id_master_++),
         name_(name), 
         age_(age) {
        std::cout << "Person(std::string const&, int) id = " << id_ << " and id_master_ is incremented to " << id_master_ <<std::endl;
    }
    std::string const& name() const { return name_; }
    int age() const { return age_; }
private:
    static int id_master_;
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, unsigned int /*version*/)
    {
        ar & name_;
        ar & age_;
        std::cout << "before store or load id = " << id_ << std::endl;
        ar & id_; // *1
        std::cout << "after store or load id = " << id_ << std::endl;
    }
    int id_;
    std::string name_;
    int age_;
};

int Person::id_master_;

int main()
{
    {
        Person p1("John", 25);
        std::ofstream ofs("person.txt");
        boost::archive::text_oarchive oa(ofs);
        oa << p1;
    }
    {
        std::ifstream ifs("person.txt");
        boost::archive::text_iarchive ia(ifs);
        Person p2;
        ia >> p2;
        assert(p2.name() == "John");
        assert(p2.age() == 25);
    }
}

The object's id is overwritten by loaded data at *1.

It seems to make no harm to my program, because after calling constructor all works great.

Harmful or not harmful is depends on your situation. Objects are deserialized as you expected, but in my example, id_master_ is incremented to 2. Be caraful that behavior.