标签: boost-serialization

有这些图书馆经验的人对他们喜欢哪一个有任何评论吗？使用中是否存在任何性能差异或困难？

我一直在使用Boost序列化库,这实际上非常好,并且让我使用简单的包装器将可序列化对象保存到字符串中,如下所示:

namespace bar = boost::archive;
namespace bio = boost::iostreams;

template <class T> inline std::string saveString(const T & o) {
 std::ostringstream oss;
 bar::binary_oarchive oa(oss);
 oa << o;
 return oss.str();
}
template <class T> inline void saveFile(const T & o, const char* fname) {
 std::ofstream ofs(fname, std::ios::out|std::ios::binary|std::ios::trunc);
 bar::binary_oarchive oa(ofs);
 oa << o;
}
template <class T> inline void loadFile(T & o, const char* fname) {
 std::ifstream ifs(fname, std::ios::in|std::ios::binary);
 assert(ifs.good()); // XXX catch if file not found
 bar::binary_iarchive ia(ifs);
 ia >> o;
} …

我知道有一个用于序列化的Boost模块boost::shared_ptr,但我找不到任何东西std::shared_ptr.

另外,我不知道如何轻松实现它.我怕以下代码

namespace boost{namespace serialization{
template<class Archive, class T>
inline void serialize(Archive & ar, std::shared_ptr<T> &t, const unsigned int version)
{
  if(Archive::is_loading::value) {T*r;ar>>r;t=r;}
  else {ar<<t.get();}
}
}}//namespaces

不起作用.实际上,如果某个对象被多次引用,它将被第一次运行加载ar>>r,之后只会复制一个指针.但是,我们会创建shared_ptr指向它的多个对象,因此会多次破坏它.

有什么想法吗？

关于我正在使用的系统的一些技术细节:

• 操作系统:Ubuntu 11.10(x64)
• 编译器:g ++(Ubuntu/Linaro 4.6.1-9ubuntu3)4.6.1
• 升级版:1.46.1(已安装sudo apt-get install libboost-dev)

我目前正在研究如何改进我们当前的c ++网络手工序列化机制,维护我们现有的二进制协议.第一种方法是使用Boost.Asio使用Boost.Serialisation使用二进制序列化对其进行编码.无论如何,它发现它比我们目前的手工制作实施有点慢(10%).任何人都有关于使用谷歌protobuf和Boost.Asio的实际_real_work_经验？

我搜索谷歌的样本,但只能得到这个例子:

使用谷歌协议缓冲样本提升Asio

有人在任何实际项目中都这样做过吗？我对性能数据非常感兴趣,因为它必须非常快......

通过基类指针序列化派生类时,我遇到了一些boost序列化问题.我需要一个系统,它在系统中接收某些对象时将其序列化,因此我需要随着时间的推移进行序列化.这不是一个真正的问题,因为我可以boost::archive::binary_oarchive在需要时打开并序列化对象.我很快注意到boost是通过内存地址执行对象跟踪,所以第一个问题是共享相同内存地址的不同对象被保存为同一个对象.这可以通过在所需的派生类中使用以下宏来修复:

BOOST_CLASS_TRACKING(className, boost::serialization::track_never)

这样可以正常工作,但同样,当基类不是抽象类时,基类没有正确序列化.在以下示例中,基类序列化方法仅使用第一个对象调用一次.在下文中,boost假定此对象之前已被序列化,尽管该对象具有不同的类型.

#include <iostream>
#include <fstream>
#include <boost/serialization/export.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/archive/archive_exception.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>

using namespace std;

class AClass{
public:
    AClass(){}
    virtual ~AClass(){}
private:
    double a;
    double b;
    //virtual void virtualMethod() = 0;
private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & a;
        ar & b;
        cout << "A" << endl;
    }
};
//BOOST_SERIALIZATION_ASSUME_ABSTRACT(Aclass)
//BOOST_CLASS_TRACKING(AClass, boost::serialization::track_never)

class BClass …

boost是否支持c ++ 11的std :: tuple的序列化？

我在/ boost/serialization /找不到tuple.hpp头文件

我正在使用boost 1.52.0(如果需要,很高兴升级,但似乎版本1.53中的更改没有任何与此相关的内容).

我使用Boost.Serialization来序列化std :: map.代码看起来像这样

void Dictionary::serialize(std::string & buffer)
{
  try {
    std::stringstream ss;
    boost::archive::binary_oarchive archive(ss);
    archive << dict_; 
    buffer = ss.str();
  } catch (const std::exception & ex) {
    throw DictionaryException(ex.what());
  }
}

void Dictionary::deserialize(const char * const data, int length)
{
  try {
    namespace io = boost::iostreams;
    io::array_source source(data, length);
    io::stream<io::array_source> in(source);
    boost::archive::binary_iarchive archive(in);
    archive >> dict_;
  } catch (const std::exception & ex) {
    throw DictionaryException(ex.what());
  }
}

我在Mac Snow Leopard和Ubuntu Lucid 10.04上编译并测试了代码.两个系统都有Boost 1.40.在Mac上我自己构建了代码.在Ubuntu框中,我通过aptitude获得了二进制文件.

问题:当我在Mac上序列化地图时,我无法在Ubuntu框中反序列化它.如果我尝试,我会收到无效的签名异常.

我正在使用boost序列化.我用:编译-L/opt/local/lib -lboost_serialization -stdlib=libc++,但有几个(不可插入的)错误:

Undefined symbols for architecture x86_64:
  "boost::archive::text_oarchive_impl::save(std::__1::basic_string, std::__1::allocator > const&)", referenced from:
      void boost::archive::save_access::save_primitive, std::__1::allocator > >(boost::archive::text_oarchive&, std::__1::basic_string, std::__1::allocator > const&) in main.o
  "boost::archive::basic_text_oprimitive > >::~basic_text_oprimitive()", referenced from:
      boost::archive::text_oarchive_impl::~text_oarchive_impl() in main.o
  "boost::archive::text_oarchive_impl::text_oarchive_impl(std::__1::basic_ostream >&, unsigned int)", referenced from:
      boost::archive::text_oarchive::text_oarchive(std::__1::basic_ostream >&, unsigned int) in main.o
ld: symbol(s) not found for architecture x86_64

我正在序列化std::vector<std::string>:

boost::archive::text_oarchive oa(std::cout);
oa << tasks;

我安装boost有问题吗？

boost库是包含32位和64位机器代码的通用二进制文件(所以这不是我猜的问题):

$ file libboost_serialization.dylib
libboost_serialization.dylib: Mach-O universal binary with 2 architectures
libboost_serialization.dylib (for architecture i386): Mach-O dynamically linked shared library i386 …

我正在尝试序列化指向多态类的指针Shape.所以我需要使用BOOST_CLASS_EXPORT宏来为每个子类定义一个GUID.问题:在哪里放？

让我先展示一个最小的测试用例:

shapes.hpp

#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>

class Shape {
    friend class boost::serialization::access;

    template<typename Archive>
    void serialize(Archive &ar, unsigned int const version) {
        // nothing to do
    }

    public:
        virtual ~Shape() { }
};

class Rect : public Shape {
    friend class boost::serialization::access;

    template<typename Archive>
    void serialize(Archive &ar, unsigned int const version) {
        ar & boost::serialization::base_object<Shape>(*this);
    }

    public:
        virtual ~Rect() { }
};

#ifdef EXPORT_IN_HEADER
    BOOST_CLASS_EXPORT(Rect)
#endif

export.cpp

#include <boost/serialization/export.hpp>
#include "shapes.hpp"

#ifdef …

这是一个新手问题.我试图将一些对象序列化为XML,但生成的XML包含boost序列化签名,版本信息,类ID,等等.我不需要.有没有办法在没有后处理xml消息的情况下摆脱它们？

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

using namespace std;

class Test {
private:    
    friend class boost::serialization::access;
    template<class Archive> void serialize(Archive & ar,
            const unsigned int version) {
        ar & BOOST_SERIALIZATION_NVP(a);
        ar & BOOST_SERIALIZATION_NVP(b);
        ar & BOOST_SERIALIZATION_NVP(c);
    }

    int a;
    int b;
    float c;
public:
    inline Test(int a, int b, float c) {
        this->a = a;
        this->b = b;
        this->c = c;
    }
};

int main() {
    std::ofstream ofs("filename.xml");

    Test* test = new Test(1, 2, 3.3);

    boost::archive::xml_oarchive oa(ofs); …