std :: bad_alloc on boost :: archive :: binary_iarchive

Question

У меня есть метод выше, который сериализует общий класс.

std::unique_ptr<Message> Serializer::deserialize(char* data , int size) { 
    std::stringstream ss(std::ios_base::in | 
          std::ios_base::out | 
          std::ios_base::binary); 
    ss.write(data, size); 
    Message *in; 

    boost::archive::binary_iarchive ia(ss, boost::archive::no_header); 
    ia >> in; 
    return std::unique_ptr<Message> (in); 
} 

Я получаю

terminate called after throwing an instance of 'std::bad_alloc' 
    what(): std::bad_alloc 

, когда я пытаюсь вызвать десериализации на символ *, который я уверен, отправляется одно целое. Класс, который я пытаюсь десериализации, чтобы можно найти здесь:

class DiscoveryMessage : public Message { 
public: 

    DiscoveryMessage() {} 

    DiscoveryMessage(int tcpPort); 

    virtual ~DiscoveryMessage(){} 

    friend class boost::serialization::access; 

private: 
    template <class Archive> 
    void serialize(Archive &ar, const unsigned int) { 
    // invoke serialization of base class (Message) 
    ar & boost::serialization::base_object<Message>(*this); 
    ar & mTcpReceivePort; 
    ar & mIPAddr; 
    } 

    int mTcpReceivePort; 
    std::string mIPAddr; 
}; 

Answer 1

Убедитесь, что вы действительно десериализации того же типа, как вы сериализованная.

В частности, я вижу, как вы смешиваете в unique_ptr и производных классах. Например. Вы не можете использовать приведенный выше код для десериализации DiscoveryMessage* или boost::shared_ptr<Message> т.д.

Простой демо:

Live On Coliru

#include <boost/serialization/serialization.hpp> 
#include <boost/serialization/base_object.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/archive/text_oarchive.hpp> 
#include <boost/serialization/export.hpp> 

class DiscoveryMessage; 
struct Message { 
    virtual ~Message() {} 

    virtual void do_print(std::ostream& os) const { os << "(base)"; } 

    friend std::ostream& operator<<(std::ostream& os, Message const& m) { 
     m.do_print(os); 
     return os; 
    } 

    template <class Archive> void serialize(Archive &ar, const unsigned int) { 
     ar.template register_type<DiscoveryMessage>(); 
    } 
}; 

class DiscoveryMessage : public Message { 
    public: 
    DiscoveryMessage() {} 

    DiscoveryMessage(int tcpPort) : mTcpReceivePort(tcpPort) {} 
    virtual void do_print(std::ostream& os) const { 
     os << "{" << mIPAddr << ":" << mTcpReceivePort << "}"; 
    } 

    private: 
    friend class boost::serialization::access; 
    template <class Archive> void serialize(Archive &ar, const unsigned int) { 
     // invoke serialization of base class (Message) 
     ar & boost::serialization::base_object<Message>(*this); 
     ar & mTcpReceivePort; 
     ar & mIPAddr; 
    } 

    int mTcpReceivePort; 
    std::string mIPAddr = "hello"; 
}; 

BOOST_CLASS_EXPORT(Message) 
BOOST_CLASS_EXPORT(DiscoveryMessage) 

#include <sstream> 
#include <iostream> 

int main() 
{ 
    std::stringstream ss; 
    { 
     boost::archive::text_oarchive oa(ss); 
     Message * p = new DiscoveryMessage(42); 
     oa << p; 
    } 

    { 
     boost::archive::text_iarchive ia(ss); 
     Message * p; 
     ia >> p; 
     std::cout << *p << "\n"; 
    } 
} 

Печать

{hello:42}