使用指針和非默認構造函數來增強序列化

Question

你會如何使用boost :: serialization序列化/反序列化這個類？

#include <vector>

struct Foo {
    struct Bar {
        std::vector<int> * data; // Must point to Foo::data

        Bar( std::vector<int> * d ) : data(d) { }
    };

    std::vector<int> data;
    std::vector<Bar> elements;

    Foo() {
        // do very time consuming calculation to populate "data" and "elements"
    }
};

當從序列化數據加載對象時，不得執行Foo中的構造函數，但如果對象是默認構造的，則必須對構造函數進行求值。

可以向Bar添加默認構造函數，但在序列化之后，Foo :: Bar :: data必須指向Foo :: data。

編輯：以下是我的嘗試的非工作實現

這是我基於@Matthieu提示的嘗試。 問題是，當我反序列化Foo時，我在Foo :: data和Foo :: elements中沒有得到任何元素。

struct Foo {
    struct Bar {
        std::vector<int> * data;

        Bar( ) : data( 0 ) { }
        Bar( std::vector<int> * d ) : data(d) { }

        template<class Archive>
        void serialize(Archive & ar, const unsigned int version) {
            ar & data;
        }
    };

    std::vector<int> data;
    std::vector<Bar> elements;

    Foo() {
        std::cerr << "Running default constructor" << std::endl;
        data.push_back(1);
        data.push_back(2);
        data.push_back(3);
        data.push_back(4);
        data.push_back(5);
        elements.push_back( Bar( &data ) );
        elements.push_back( Bar( &data ) );
        elements.push_back( Bar( &data ) );
    }

    template<class Archive>
    Foo( Archive & ar ) {
        ar >> data; // is this corrent?
        ar >> elements;
    }

private:
    BOOST_SERIALIZATION_SPLIT_MEMBER();
    friend class boost::serialization::access;

    template<class Archive>
    void save(Archive & ar, const unsigned int version) const {
        const std::vector<int> * data_ptr = &data;

        // should data be seriliazed as pointer...
        // it is used as a pointer in Bar
        ar << data_ptr;
        ar << elements;
    }
};

int main(int argc, const char *argv[])
{
#if 0
    // serialize
    Foo foo;
    boost::archive::text_oarchive oar(std::cout);
    oar << foo;

#else
    // deserialize
    boost::archive::text_iarchive oar(std::cin);
    Foo foo(oar);

#endif
    std::cerr << foo.data.size() << std::endl;
    std::cerr << foo.elements.size() << std::endl;

    std::cerr << (&foo.data) << std::endl;
    for( const auto& a : foo.data )
        std::cerr << a << " ";
    std::cerr << std::endl;

    for( const auto& a : foo.elements)
        std::cerr << a.data << " ";
    std::cerr << std::endl;

    return 0;
}

Answer 1

文檔中有一節描述如何（de）使用非默認構造函數序列化類。 看到這里 。

基本上，您必須在命名空間boost::serialization實現名為save_construct_data和load_construct_data兩個函數，以寫出並讀入用於構造類實例的數據。 然后，您可以使用重建Foo對象所需的參數從load_construct_data函數調用Foo的非默認構造函數。

---

這是一個基於您更新的代碼的工作示例：

請注意，我已經使用shared_ptr來澄清由Foo和Bar序列化的data成員引用相同的東西。

#include <vector>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <iostream>
#include <sstream>

struct Foo {
    struct Bar {
        boost::shared_ptr< std::vector<int> > data; // Must point to Foo::data

        Bar( boost::shared_ptr< std::vector<int> > d ) : data(d) { }

        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
          // ** note that this is empty **
        }
    };

    boost::shared_ptr< std::vector<int> > data;
    std::vector<Bar> elements;

    Foo() : data( new std::vector<int>() ) {
        std::cerr << "Running default constructor" << std::endl;
        data->push_back(1);
        data->push_back(2);
        data->push_back(3);
        data->push_back(4);
        data->push_back(5);
        elements.push_back( Bar( data ) );
        elements.push_back( Bar( data ) );
        elements.push_back( Bar( data ) );
    }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
      // ** note that this is empty **
    }

    Foo(
      boost::shared_ptr< std::vector<int> > const & data_,
      std::vector<Bar> const & elements_ ) : data( data_ ), elements( elements_ )
    {
        std::cout << "cheap construction" << std::endl;
    }
};

namespace boost { namespace serialization {

template<class Archive>
inline void save_construct_data(
    Archive & ar, const Foo * foo, const unsigned int file_version
){
    ar << foo->data << foo->elements;
}

template<class Archive>
inline void load_construct_data(
    Archive & ar, Foo * foo, const unsigned int file_version
){
    boost::shared_ptr< std::vector<int> > data;
    std::vector<Foo::Bar> elements;

    ar >> data >> elements;

    ::new(foo)Foo(data, elements);
}

template<class Archive>
inline void save_construct_data(
    Archive & ar, const Foo::Bar * bar, const unsigned int file_version
){
    ar << bar->data;
}

template<class Archive>
inline void load_construct_data(
    Archive & ar, Foo::Bar * bar, const unsigned int file_version
){
    boost::shared_ptr< std::vector<int> > data;

    ar >> data;

    ::new(bar)Foo::Bar(data);
}

}}

int main()
{
  std::stringstream ss;

  {
    boost::scoped_ptr< Foo > foo( new Foo() );

    std::cout << "size before serialization is: " << foo->data->size() << std::endl;

    boost::archive::text_oarchive oa(ss);
    oa << foo;
  }

  {
    boost::scoped_ptr< Foo > foo;

    boost::archive::text_iarchive is(ss);
    is >> foo;

    std::cout << "size after deserialization is: " << foo->data->size() << std::endl;
  }

  return 0;
}