c++ - Boost 将派生类反序列化为基类指针

标签 c++ boost boost-serialization

请帮助我将派生类反序列化为基类指针。我附上完整的源代码示例。

request.hpp(无配对 cpp 文件)

#ifndef REQUEST_HPP
#define REQUEST_HPP

#include <memory>
#include <string>

#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>

namespace demo {
namespace common {

        class request {
        public:
            static const int INVALID_ID = -42;

            request() 
                : id_(INVALID_ID), timestamp_(0), source_ip_("unknown") {};

            request(int id, long timestamp, const std::string& source_ip) 
                : id_(id), timestamp_(timestamp), source_ip_(source_ip) {};

            virtual ~request() {};

            int id() const { return id_; }
            long timestamp() const { return timestamp_; }
            std::string source_ip() const { return source_ip_; }



        protected:
            int id_;
            long timestamp_;
            std::string source_ip_;



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

            template<class Archive>
            void serialize(Archive& ar, const unsigned version) {
                ar & BOOST_SERIALIZATION_NVP(id_);
                ar & BOOST_SERIALIZATION_NVP(timestamp_);
                ar & BOOST_SERIALIZATION_NVP(source_ip_);
            }

        };

        typedef std::shared_ptr<request> request_ptr;

    }
};

#endif

command.hpp(派生类)

#ifndef COMMAND_HPP
#define COMMAND_HPP

#include <memory>
#include <string>

#include <boost/serialization/export.hpp>

#include <demo/common/request.hpp>

namespace demo {
    namespace common {

            class command : public request {
            public:
                command(): name_("untitled") {};
                explicit command(const std::string& name) : name_(name) {};
                virtual ~command() {};

                virtual void execute();

                std::string name() const { return name_; }

            protected:
                std::string name_;

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

                template<class Archive>
                void serialize(Archive& ar, const unsigned version) {
                    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(request);
                    ar & BOOST_SERIALIZATION_NVP(name_);
                }

            };

            typedef std::shared_ptr<command> command_ptr;

        }
};

BOOST_CLASS_EXPORT_KEY(demo::common::command)


#endif

命令.cpp

#include "command.hpp"
#include <iostream>

BOOST_CLASS_EXPORT_IMPLEMENT(demo::common::command)

namespace demo {
    namespace common {

            void command::execute() {
                std::cout << "  I am '" + name_ +"' and I am executing..." << std::endl;
            }

    }
};

序列化器.hpp

#ifndef SERIALIZER_HPP
#define SERIALIZER_HPP

#include <sstream>
#include <string>

/* classes to serialize */
#include <demo/common/request.hpp>
#include <demo/common/command.hpp>

namespace demo {
    namespace common {

        class serializer {
        public:
            serializer() : {};

            template<typename T>
            std::string serialize(const T& t){  
                std::stringstream stream;
                boost::archive::xml_oarchive archive(stream);
                archive << BOOST_SERIALIZATION_NVP(t);
                std::string serialized = stream.str();

                return serialized;
            }


            template<typename T>
            void deserialize(const std::string& serialized, T& t) {
                std::stringstream stream(serialized);
                boost::archive::xml_iarchive archive(stream);
                archive >> BOOST_SERIALIZATION_NVP(t);
            }
        };

    }
}

#endif

示例用法

#include <iostream>

#include <demo/common/serializer.hpp>
#include <demo/common/command.hpp>


using namespace std;
using namespace demo::common;

int main(){
    serializer serializer_;

    command r("123"); // <-- (1) my desired way of declaring
    //request* r = new command("123"); <-- (2) replacing with this makes all work!
    //command* r = new command("123"); <-- (3) replacing with this crashes the app, like (1)
    std::string s = serializer_.serialize(r);
    std::cout << s << std::endl;
    request* rr = nullptr;
    serializer_.deserialize(s, rr); //this throws an exception

    command* rrr = dynamic_cast<command*>(rr);

    rrr->execute();
}

我以为我做了所有需要做的事情，在任何类导出之前包含文件，所有默认构造函数初始化成员..

请注意，可序列化类和序列化器被编译为 lib 文件。然后该库在两个子项目中使用，这两个子项目可以访问 header 并链接该库。他们使用这些类相互通信，通过网络发送序列化对象。

为什么我无法将派生类反序列化为基类指针？ 我正在使用 Boost 1.51 和 VC11。

最佳答案

问题:

我发现关于 Boost::serialization 导致我出现问题的两个主要问题如下:

  1. 堆栈上的对象与堆上的对象混合的序列化/反序列化。例如，如果您从堆栈上的对象序列化，然后尝试反序列化为指针(例如调用您的 load_construct_data<> ) 可能会出现异常。与相反的情况相同。
  2. 未正确链接导出内容。例如，如果您创建序列化模板/类并将它们放入 .lib 中，则导出可能无法正确链接/公开。这适用于链接到共享对象/DLL，然后使用它。

解决方案:

对于#1，我发现制定始终对指针进行序列化/反序列化的规则是最简单的。即使堆栈上的对象也可以在序列化时使用临时指针以允许此规则。例如:

// serialize
MyObject myobj;
std::ostringstream oss;
boost::archive::text_oarchive oa(oss);
MyObject* myObjPtr = &myObj;
oa << myObjPtr; // this is different than oa << myObj!!
std::string serialized = oss.str();

// deserialize
MyObject* myNewObjPtr;
std::stringstream iss(serialized);
boost::archive::text_iarchive ia(iss);
ia >> myNewObjPtr; // invokes new, don't forget to delete (or use smart ptrs!!!)

对于#2，只需创建一个包含所有导出的 .cpp 文件。将此 CPP 直接链接到您的模块中。换句话说，您将拥有一个带有一堆 BOOST_CLASS_EXPORT_IMPLMENT() 的 .cpp:

BOOST_CLASS_EXPORT_IMPLEMENT(MyObject);
// ...

更完整的示例:
下面是一个更完整的示例，显示了一些使用非侵入式模板的序列化技巧。侵入式成员方法将非常相似:

MyObject.h

// Can be broken into MyObject.h, MyObject.cpp, MyObjectSerialization.h for example as well. 
// This stuff can live in your .lib
#include <boost/serialization/export.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
// assume this class contains GetSomeMember() returning SomeMemberType
class MyObject { /* ... */ };
BOOST_CLASS_EXPORT_KEY(MyObject);
namespace boost { namespace serialization {
  template<class Archive>
      void serialize(Archive& ar, MyObject& myObj, const unsigned int version)
  {
      ar & myObj.m_someMember;
  }

  template<class Archive>
      inline void save_construct_data(Archive& ar, const MyObject* myObj, const unsigned int version)
  {
    ar & boost::serialization::make_nvp("SomeMemberType", static_cast<const SomeMemberType&>(myObj->GetSomeMember()));
  }

  template<class Archive>
  inline void load_construct_data(Archive& ar, MyObject* myObj, const unsigned int version)
  {
      SomeMemberType t;
      ar & boost::serialization::make_nvp("SomeMemberType", t);
      ::new(myObj)MyObject(t);
  }
} } // end boost::serialization ns

MyObjectExports.cpp

// This file must be explicitly linked into your module(s) that use serialization.
// This means your executable or shared module/DLLs
#include <boost/serialization/export.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include "MyObject.h"

BOOST_CLASS_EXPORT_IMPLEMENT(MyObject);

关于c++ - Boost 将派生类反序列化为基类指针，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13089884/

上一篇：c++ - 是否可以将整个枚举集作为参数传递？

下一篇：c++ - 使用 automake 安装 header

相关文章：

c++ - 在索引处 boost 几何多边形插入点

c++ - 使用 boost::mpl::bitor_

c++ - 如何为 boost::serialization 指定 nvp 包装器？

C++11 std::shared_ptr + boost::序列化

c++ - 帮我调试这个 - C++ Boost

c++ - 使用 Boost 序列化生成 operator==？

c++ - unsigned long long 的问题

C++复制控制问题

c++ - 将短列表合并为长 vector 的算法

c++ - 在 C++ 中使用方法作为变量

©2024 IT工具网  联系我们