C ++ Boost.Serialization误差与为重点的自定义对象的hash_map [英] C++ Boost.Serialization error for hash_map with custom objects as key

问题描述

我需要序列化的对象，包括与另一对象为重点的的hash_map。被用作键的对象是其他对象的基类。我已经实现序列化（）方法在基类和派生类，和每一个派生类继承的基类的序列化方法。这种情况与此类似：

I need to serialize an object that include an hash_map with another object as key. The object that is used as key is a base class for other objects. I have implemented the serialize() method in the base class and in derived classes, and each derived class inherits the serialization method of the base class. The situation is similar to this:

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/hash_map.hpp> 
#include <boost/serialization/base_object.hpp>

class Item {
protected:

    unsigned int _refc;
    static unsigned int _total_alloc;

//other code

private:
    friend class boost::serialization::access;

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

class StringItem : public Item {
private:
    string _s;

    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
    ar & boost::serialization::base_object<Item>(*this);    
    ar & _s;
    }

};

这是我需要序列化类：

class TokenFinder : public Model {
public:

     TokenFinder(void);

     virtual ~TokenFinder(void);

     virtual void insert_item(Item *item);

private:
/** Map to store tokens together with their number of occurrences. 
*/
     __gnu_cxx::hash_map<Item *, unsigned long> _elements;
     unsigned long _element_count;

     friend class boost::serialization::access;
     template<class Archive>
     void serialize(Archive & ar, const unsigned int version)
     {
       ar & _elements; //Error when saved
       ar & _element_count;
 }
};

当我尝试序列化对象TokenFinder的错误是：终止叫做抛出的一个实例的boost ::存档:: archive_exception后
  什么（）：未注册类 - 未注册或导出派生类

When I try to serialize a TokenFinder object the error is: terminate called after throwing an instance of 'boost::archive::archive_exception' what(): unregistered class - derived class not registered or exported

有什么建议？在此先感谢！

Any suggestions? Thanks in advance!

推荐答案

尝试用注册项目的子类存档使用前：

Try registering the subclasses of Item with the Archive prior to use:

template<class Archive>
    void serialize(Archive & ar, unsigned)
    {
        ar.template register_type<StringItem>(); // THIS

        ar & boost::serialization::base_object<Model>(*this);    
        ar & _elements;
        ar & _element_count;
    }

看到 现场演示在Coliru

See a Live demo On Coliru

输出

22 serialization::archive 10 0 0 0 0 0 0 6 0 0 0 1 1 0
0 1 0
1 0 10 cow-jumped 6 1
2
3 0 4 moon 5 1
4
5 0 4 lazy 4 1
6
7 0 3 the 3 1
8
9 0 5 world 2 1
10
11 0 5 hello 1 0

注

• 我定义了的std :: unordered_map 序列化，所以你不再需要去precated GNU库扩展使用（见的这个错误报告/补丁）


• 我注释掉 _total_alloc ，因为，当然，你不希望这个数字反序列化


• 在我离开的管理项目 S中的生命周期/分配作为一个练习（我不知道你是怎么想举办所有权语义）

• I defined serialization for std::unordered_map so you no longer have to use deprecated GNU library extensions (see also this bug-report/patch)
• I commented out the _total_alloc because, surely, you don't want this number de-serialized
• I left managing the lifetime/allocation of Items as an exercise (I don't know how you wanted ownership semantics organized)

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

#include <unordered_map>
#include <boost/serialization/collections_save_imp.hpp>
#include <boost/serialization/collections_load_imp.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/split_free.hpp>

namespace boost { namespace serialization {

    template<class Archive, typename... TArgs >
        inline void save(Archive & ar, std::unordered_map<TArgs...> const&t, unsigned) {
            boost::serialization::stl::save_collection<Archive, std::unordered_map<TArgs...> >(ar, t);
        }

    template<class Archive, typename... TArgs >
        inline void load(Archive & ar, std::unordered_map<TArgs...> &t, unsigned) {
            boost::serialization::stl::load_collection<Archive,
                std::unordered_map<TArgs...>,
                boost::serialization::stl::archive_input_map<
                    Archive, std::unordered_map<TArgs...> >,
                boost::serialization::stl::no_reserve_imp<std::unordered_map<TArgs...> >
                    >(ar, t);
        }

    // split non-intrusive serialization function member into separate
    // non intrusive save/load member functions
    template <class Archive, typename... TArgs>
        inline void serialize(Archive & ar, std::unordered_map<TArgs...> &t, unsigned file_version) {
            boost::serialization::split_free(ar, t, file_version);
        }
} }

#include <boost/serialization/base_object.hpp>

class StringItem;

class Item {
  protected:
    unsigned int _refc;
    static unsigned int _total_alloc;

    //other code
    Item() : _refc(0) { }
    virtual ~Item() {}

  private:
    friend class boost::serialization::access;

    template<class Archive>
        void serialize(Archive & ar, unsigned)
    {
        ar & _refc;
        //ar & _total_alloc; // wut? a static?!
    }
};

/*static*/ unsigned int Item::_total_alloc;

class StringItem : public Item {
  public:
    StringItem(std::string s = "") : _s(std::move(s)) { }
  private:
    std::string _s;

    friend class boost::serialization::access;
    template<class Archive>
        void serialize(Archive & ar, unsigned)
        {
            ar & boost::serialization::base_object<Item>(*this);    
            ar & _s;
        }
};


struct Model {
    virtual ~Model() {}
    template<class Archive> void serialize(Archive&r, unsigned) { }
};

class TokenFinder : public Model
{
  public:
    TokenFinder(void) : _element_count(0) {}

    virtual ~TokenFinder(void) {}

    virtual void insert_item(Item *item) { _elements[item] = _elements.size()+1; }

  private:
    /** Map to store tokens together with their number of occurrences. */
    std::unordered_map<Item*, unsigned long> _elements;
    unsigned long _element_count;

    friend class boost::serialization::access;
    template<class Archive>
        void serialize(Archive & ar, unsigned)
        {
            ar.template register_type<StringItem>();
            ar & boost::serialization::base_object<Model>(*this);    
            ar & _elements;
            ar & _element_count;
        }
};

int main()
{
    boost::archive::text_oarchive oa(std::cout);

    std::vector<StringItem> seed_data {
        {"hello"},{"world"},{"the"},{"lazy"},{"moon"}, {"cow-jumped"} 
    };



    TokenFinder tf;
    for(auto& si : seed_data)
        tf.insert_item(&si);

    oa << tf;

}

这篇关于C ++ Boost.Serialization误差与为重点的自定义对象的hash_map的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！