Question

我必须在抽象类的Boost向量（或任何其他容器）中序列化。因为不可能直接创建抽象类的向量，所以我在这个抽象类中创建了reference_wrapper的向量。

但是如何在Boost std :: reference_wrapper中序列化为抽象类？当我尝试直接执行它时，我收到一个错误，reference_wrapper的默认构造函数是不可访问的。

提前致谢。

Answer 1

更多地考虑这个问题，你不想序列化参考文献。

由于逻辑引用是不可重复的，并且不会保留任何数据，因此它们永远不会被反序列化＆＃34; （他们会指出什么？临时？泄漏的堆对象？）。

当然reference_wrappers 是可重新排列的，但在这种情况下，您真的只是将它们用作原始指针（可能拥有指针）。< / p>

在这种情况下，只需将它们序列化为指针，并可选择使用对象跟踪来防止重复（反）序列化。

提示我认为您可以从内置序列化支持的boost::ptr_vector中受益。请参阅下文（和docs）

演示

虽然提出了一种简单的方法，并且教授＆＃34;提升序列化以使用reference_wrapper作为原始指针（可能你需要的东西）：

<强> Live On Coliru

/////////////////////////////////////////////////
// Allow serialization of `reference_wrapper`
namespace boost { namespace serialization {
    template<class Ar, class T> void save_construct_data(Ar & ar, std::reference_wrapper<T> const * t, unsigned) {
        T const * p = &t->get();
        ar << p;
    }
    template<class Ar, class T> void load_construct_data(Ar & ar, std::reference_wrapper<T> * t, unsigned) {
        T* p = nullptr;
        ar >> p;
        ::new(t) std::reference_wrapper<T>(*p);
    }

    template <class Ar, typename T> inline void serialize(Ar &, std::reference_wrapper<T>&, unsigned) { }
} }

然而，我发现，reference_wrapper不是默认构造可能会严重破坏std :: vector被反序列化的事实，这是一个更大的问题。

当你的意思是指针时，我简化并只使用指针：

<强> Live On Coliru

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/export.hpp>

#include <boost/ptr_container/serialize_ptr_vector.hpp>
#include <functional>

using namespace boost;

/////////////////////////////////////////////////
// defining a virtual class hierarchy...
struct B {
    virtual ~B() = default;
    virtual std::ostream& print(std::ostream& os) const { return os << __PRETTY_FUNCTION__; }

  private:
    friend class boost::serialization::access;
    template <typename Ar> void serialize(Ar&, unsigned) const {
    }
};

struct D1 : B {
    virtual std::ostream& print(std::ostream& os) const { return os << _data; }

  private:
    std::string _data = "forty two";

    friend class boost::serialization::access;
    template <typename Ar> void serialize(Ar& ar, unsigned) {
        ar & boost::serialization::base_object<B>(*this);
        ar & _data;
    }
};

struct D2 : B {
    virtual std::ostream& print(std::ostream& os) const { return os << _data; }

  private:
    int _data = 42;

    friend class boost::serialization::access;
    template <typename Ar> void serialize(Ar& ar, unsigned) {
        ar & boost::serialization::base_object<B>(*this);
        ar & _data;
    }
};

BOOST_CLASS_EXPORT(B)
BOOST_CLASS_EXPORT(D1)
BOOST_CLASS_EXPORT(D2)

/////////////////////////////////////////////////
// sample data structure representing our program

struct Data {
    ptr_vector<B> storage;
    std::vector<B*> refvect;

    void fill_sample() {
        storage.push_back(new D1);
        storage.push_back(new D1);
        storage.push_back(new D2);
        storage.push_back(new D1);

        refvect.clear();
        for (auto it = storage.rbegin(); it != storage.rend(); ++it)
            refvect.push_back(&*it);
    }

    friend std::ostream& operator<<(std::ostream& os, Data const& data) {
        for (auto i : data.refvect) i->print(std::cout) << "\n";
        return os;
    }

    template <typename Ar> void serialize(Ar& ar, unsigned) {
        ar & storage & refvect;
    }
};

#include <sstream>
int main() {

    std::stringstream stream;
    {
        archive::binary_oarchive oa(stream);

        Data x;
        x.fill_sample();
        oa << x;

        std::cout << "Before:\n" << x << "\n";
    }

    {
        archive::binary_iarchive ia(stream);

        Data y;
        ia >> y;
        std::cout << "After:\n" << y << "\n";
    }

}

打印

Before:
forty two
42
forty two
forty two

After:
forty two
42
forty two
forty two

reference_wrapper在boost中抽象类序列化

1 个答案:

演示