C++ - boost ::任何序列化

Question

据我所知,没有序列化(boost::serialization实际上)支持boost::any占位符.

有人知道是否有办法序列化自定义boost::any实体？

这里的问题很明显:boost::any使用基于模板的占位符来存储对象并typeid检查是否boost::any_cast合适.

因此,有一个自定义抽象超类placeholder和基于自定义模板的派生类,它们通过以下方式创建:

template <T> custom_placeholder : public placeholder {
    virtual std::type_info type() const { return typeid(T); }
    virtual ...
};

显然,即使考虑序列化这些东西,这也会带来一些麻烦.也许有人知道做这种序列化的一些技巧(当然还有正确的反序列化)？

谢谢

Answer 1

如果你想坚持使用boost ::任何我不确定但你可以编写自己的"boost :: any".我正在使用此代码来代理方法来传递参数.

#include <iostream>
#include <boost\smart_ptr\scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/export.hpp>
#include <sstream>
class my_placeholder
{
public:
    virtual ~my_placeholder(){}
    my_placeholder(){}
private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        // serialize base class information
        //ar & boost::serialization::base_object<bus_stop>(*this);
        //ar & m_placeholder;

    }

};




template<typename T>
class my_derivedplaceholder:
    public my_placeholder
{
    public:
        my_derivedplaceholder()
        {

        }
        my_derivedplaceholder(T &value)
        {
            m_value=value;
        }
    T m_value;

private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        // serialize base class information
        ar & boost::serialization::base_object<my_placeholder>(*this);
        ar & m_value;

    }
};


BOOST_CLASS_EXPORT_GUID(my_derivedplaceholder<int>, "p<int>");


class my_any
{
public:

    my_any()
    {

    }

    template<typename T>
    my_any(const T &value)
    {
        m_placeholder.reset(new my_derivedplaceholder<T>(const_cast<T&>(value)));
    }

    template<typename T>
    void operator=(const T &value)
    {
        m_placeholder.reset(new my_derivedplaceholder<T>(const_cast<T&>(value)));
    }



protected:

    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        // serialize base class information
        //ar & boost::serialization::base_object<bus_stop>(*this);
        ar & m_placeholder;

    }

     template<typename T>
    friend    T my_anycast(my_any &val);

    boost::shared_ptr<my_placeholder> m_placeholder;
};

template<typename T>
T my_anycast(my_any &val)
{
    boost::shared_ptr<my_derivedplaceholder<T>> concrete=boost::dynamic_pointer_cast<my_derivedplaceholder<T>>(val.m_placeholder);
    if (concrete.get()==NULL)
        throw std::invalid_argument("Not convertible");

    return concrete->m_value;
}

void main()
{
    my_any m=10;

    int a=my_anycast<int>(m);

    std::cout << a << std::endl;

    std::stringstream ss,ss2;
    boost::archive::text_oarchive oa(ss);

    oa << m;

    boost::archive::text_iarchive ia(ss);

    my_any m2;
    ia >> m2;

    std::cout << my_anycast<int>(m2) << std::endl;
}

Answer 2

完全不可能,至少对于任意类型.请注意,也许您可​​以使用一些棘手的代码进行序列化(比如查找any中包含的元素的大小),但是任何代码都依赖于编译器静态地将任何type_code和正确的类型放在占位符中.你肯定不能在C++中反序列化中这样做,因为你在反编译时得到的类型在编译时是不知道的(按照新形成的要求boost::any).

最好的解决方案是为您要序列化的元素的确切类型构建某种专用的任何类型.然后,您可以对要反序列化的元素的实际类型有特殊情况,但请注意,每个元素类型序列化/反序列化必须在逻辑上写为静态C++代码.

PD.其他一些人建议使用boost::variant这种特殊类型的表示来保存您要序列化的确切类型.但是,您需要一种方法来识别反序列化的确切类型(可能为变体中的类型指定标识符).