Boost序列化小结

已于 2025-01-10 11:05:05 修改
阅读量841 收藏 14
点赞数 25
文章标签： Boost序列化
于 2025-01-08 10:39:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23350817/article/details/144999716
版权

Boost.Serialization 提供了多个归档类，如 boost::archive::text_oarchive 类，它定义在 boost/archive/text_oarchive.hpp 文件中。 boost::archive::text_oarchive，可将对象序列化为文本流。

boost/archive/binary_iarchive.hpp定义了 binary_iarchive 类。这个类用于从二进制格式的数据流中读取数据并反序列化对象。
boost/archive/binary_iarchive.hpp定义了 binary_oarchive 类。这个类用于将对象序列化为二进制格式的数据流。通过binary_oarchive和binary_iarchive可以实现网络通信形式的数据序列化/反序列化。例子如下：

std::vector<char> pack(const developer& serializable) {
    try {
        std::vector<char> data;
        stream<back_insert_device<std::vector<char>>> stream(data);
        binary_oarchive archive(stream, no_header | no_codecvt);
        const developer* pSerializable = &serializable;
        archive << pSerializable;
        stream.flush();
        return data;
    }
    catch (const archive_exception& e) {
        printf("serialization::pack failed:%s\n", e.what());
        return {};
    }
}

developerPtr unpack(const std::vector<char>& data) {
    try {
        stream<array_source> stream(array_source{ data.data(), data.size() });
        binary_iarchive archive(stream, no_header | no_codecvt);
        developer* serializable;
        archive & serializable;
        return developerPtr(serializable);
    }
    catch (const archive_exception&) {
        return nullptr;
    }
}

1、将基本数据类型保存到文件后并读取显示

#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <iostream> 
#include <fstream> 

void save() 
{ 
  std::ofstream file("archiv.txt"); 
  boost::archive::text_oarchive oa(file); 
  int i = 1; 
  oa << i; 
} 

void load() 
{ 
  std::ifstream file("archiv.txt"); 
  boost::archive::text_iarchive ia(file); 
  int i = 0; 
  ia >> i; 
  std::cout << i << std::endl; 
} 

int main() 
{ 
  save(); 
  load(); 
}

2、将自定义数据类型保存到文件并保存。

自定义的数据类型需要增加函数签名，用于支持对象的序列化和反序列化操作。

 template <typename Archive> 
 void serialize(Archive &ar, const unsigned int version)

模板参数 Archive：这个模板参数代表了一个归档类（archive class），它可以是不同类型的归档实现，例如文本归档、二进制归档或者 XML 归档等。归档对象负责将数据保存到某种格式的文件或从某种格式的文件加载数据。
成员函数 serialize：这是一个成员函数，通常定义在需要被序列化的类中。它告诉编译器如何将该类的对象转换为一系列字节（序列化）以及如何从这些字节重新构建对象（反序列化）。通过重载这个函数，你可以自定义序列化的行为，包括选择哪些成员变量参与序列化过程。
参数 version：这是一个无符号整数，用来表示当前类版本号。这有助于处理类结构的变化——如果类的结构在未来发生了变化（比如添加了新成员或移除了旧成员），你可以根据版本号采取不同的序列化逻辑来兼容旧的数据格式。

序列化与反序列化
当你调用 ar & member; 时：
如果 ar 是一个输出归档（如 boost::archive::text_oarchive），那么 & 操作符会触发序列化过程，即将 member 的值写入归档。
如果 ar 是一个输入归档（如 boost::archive::text_iarchive），那么 & 操作符会触发反序列化过程，即从归档读取数据并赋值给 member。

为了序列化用户定义类型的对话， serialize() 函数必须定义，它在对象序列化或从字节流中恢复是被调用。 由于 serialize () 函数既用来序列化又用来恢复数据， Boost.Serialization 除了 << 和 >> 之外还提供了 & 操作符。如果使用这个操作符，就不再需要在 serialize() 函数中区分是序列化和恢复了。

serialize () 在对象序列化或恢复时自动调用。它应从来不被明确地调用，所以应生命为私有的。 这样的话， boost::serialization::access 类必须被声明为友元，以允许 Boost.Serialization 能够访问到这个函数。

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <iostream>
#include <fstream>

struct Test
{
    int _a;
    int _b;

    Test() : _a(0), _b(0) {}
    Test(int a,int b) : _a(a), _b(b){}

    template<typename Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & _a;
        ar & _b;
    }

};
BOOST_CLASS_VERSION(Test, 1)

void save()
{
    std::ofstream file("archiv.txt");
    boost::archive::text_oarchive oa(file);
    Test t {10, 20};
    oa << t;
}

void load()
{
    std::ifstream file("archiv.txt");
    boost::archive::text_iarchive ia(file);
    Test t;
    ia >> t;
    std::cout << t._a << " " << t._b << std::endl;
}

int main()
{
    save();
    load();
}

BOOST_CLASS_VERSION表示声明当前的版本号。只有成员在serialize函数中进行&操作后，此成员才会进行序列化操作，否则反序列化后为空。

增加string、vector、map、boost::variant等变量后，为了序列化这些标准库的类型的对象，头文件必须相应添加#include <boost/serialization/string.hpp> 、#include <boost/serialization/vector.hpp> 、#include <boost/serialization/map.hpp>、 <boost/serialization/map.hpp>。Boost.Serialization 为许多 C++ 标准库类定义了 serialize () 函数，例子如下：

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <iostream>
#include <fstream>
#include <boost/serialization/string.hpp>
#include <boost/serialization/variant.hpp>

struct Test
{
    int _a;
    int _b;
    std::string _strData;
    boost::variant<int, std::string> _varData;

    Test() : _a(0), _b(0) {}
    Test(int a,int b) : _a(a), _b(b){}
    Test(int a,int b, std::string strData, boost::variant<int, std::string> varData)
        : _a(a), _b(b), _strData(strData), _varData(varData) {}

private：
    // 将 boost::serialization::access 声明为友元类
    friend class boost::serialization::access;
    
    template<typename Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & _a;
        ar & _b;
        if (version > 0){
            ar & _strData;
            ar & _varData;
        }
    }

};
BOOST_CLASS_VERSION(Test, 1)

void save()
{
    std::ofstream file("archiv.txt");
    boost::archive::text_oarchive oa(file);
    boost::variant<int, std::string> var(1);
    std::string strDatra = "test";
    var = "test23";
    Test t {10, 20, strDatra, var};
    oa << t;
}

void load()
{
    std::ifstream file("archiv.txt");
    boost::archive::text_iarchive ia(file);
    Test t;
    ia >> t;
    std::cout << "a:" << t._a
              << ", b:" << t._b
              << ", str:" << t._strData
              << ", var:" << t._varData
              << std::endl;
}

int main()
{
    save();
    load();
}

Boost.Serialization 还能序列化指针和引用。 由于指针存储对象的地址，序列化对象的地址没有什么意义，而是在序列化指针和引用时，对象的引用被自动地序列化。
形式上序列化和反序列化的时是指针，实际上是对指针指向的对象进行的操作。

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <iostream>
#include <sstream>

std::stringstream ss;

class person
{
public:
    person()
    {
    }

    person(int age)
        : age_(age)
    {
    }

    int age() const
    {
        return age_;
    }

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

    template <typename Archive>
    void serialize(Archive &ar, const unsigned int version)
    {
        ar & age_;
    }

    int age_;
};

void save()
{
    boost::archive::text_oarchive oa(ss);
    person *p = new person(31);
    oa << p;
    std::cout << std::hex << p << std::endl;
    delete p;
}

void load()
{
    boost::archive::text_iarchive ia(ss);
    person *p;
    ia >> p;
    std::cout << std::hex << p << std::endl;
    std::cout << std::dec << p->age() << std::endl;
    delete p;
}

int main()
{
    save();
    load();
}

上面的应用程序创建了一个新的 person 类型的对象，使用 new 创建并赋值给指针 p 。 是指针p而不是 对象*p 被序列化了。Boost.Serialization 自动地通过 p 的引用序列化对象本身而不是对象的地址。
如果归档被恢复， p 不必指向相同的地址。 而是创建新对象并将它的地址赋值给 p 。 Boost.Serialization 只保证对象和之前序列化的对象相同，而不是地址相同。

智能指针同理。如下例子中使用了智能指针 boost::scoped_ptr 来管理动态分配的 person 类型的对象。 为了序列化这样的指针，必须包含 <boost/serialization/scoped_ptr.hpp> 头文件。
在使用 boost::shared_ptr 类型的智能指针的时候需要序列化，那么必须包含 <boost/serialization/shared_ptr.hpp> 头文件。

#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/serialization/scoped_ptr.hpp> 
#include <boost/scoped_ptr.hpp> 
#include <iostream> 
#include <sstream> 

std::stringstream ss; 

class person 
{ 
public: 
  person() 
  { 
  } 

  person(int age) 
    : age_(age) 
  { 
  } 

  int age() const 
  { 
    return age_; 
  } 

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

  template <typename Archive> 
  void serialize(Archive &ar, const unsigned int version) 
  { 
    ar & age_; 
  } 

  int age_; 
}; 

void save() 
{ 
  boost::archive::text_oarchive oa(ss); 
  boost::scoped_ptr<person> p(new person(31)); 
  oa << p; 
} 

void load() 
{ 
  boost::archive::text_iarchive ia(ss); 
  boost::scoped_ptr<person> p; 
  ia >> p; 
  std::cout << p->age() << std::endl; 
} 

int main() 
{ 
  save(); 
  load(); 
}

使用二进制流的单继承例子：

#include <boost/iostreams/stream.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <iostream>
#include <sstream>
#include <string>

using namespace boost::iostreams;
using namespace boost::archive;


class person
{
public:
    person()
    {
    }

    person(int age)
        : age_(age)
    {
    }

    int age() const
    {
        return age_;
    }

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

    template <typename Archive>
    void serialize(Archive &ar, const unsigned int version)
    {
        ar & age_;
    }

    int age_;
};

class developer
    : public person
{
public:
    developer()
    {
    }

    developer(int age, const std::string &language)
        : person(age), language_(language)
    {
    }

    std::string language() const
    {
        return language_;
    }

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

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

    std::string language_;
};
using developerPtr = std::shared_ptr<developer>;

std::vector<char> pack(const developer& serializable) {
    try {
        std::vector<char> data;
        stream<back_insert_device<std::vector<char>>> stream(data);
        binary_oarchive archive(stream, no_header | no_codecvt);
        const developer* pSerializable = &serializable;
        archive << pSerializable;
        stream.flush();
        return data;
    }
    catch (const archive_exception& e) {
        printf("serialization::pack failed:%s\n", e.what());
        return {};
    }
}

developerPtr unpack(const std::vector<char>& data) {
    try {
        stream<array_source> stream(array_source{ data.data(), data.size() });
        binary_iarchive archive(stream, no_header | no_codecvt);
        developer* serializable;
        archive & serializable;
        return developerPtr(serializable);
    }
    catch (const archive_exception&) {
        return nullptr;
    }
}

int main()
{
    developer d(31, "C++");
    std::vector<char> vDatas = pack(d);
    developerPtr dptr = unpack(vDatas);

    std::cout << "language:" << dptr->language() << ", age:" << dptr->age() << std::endl;

}

person 和 developer 这两个类都包含有一个私有的 serialize () 函数， 它使得基于其他类的对象能被序列化。 由于 developer 类继承自 person 类， 所以它的 serialize () 函数必须确保继承自 person 属性也能被序列化。
继承自基类的属性被序列化是通过在子类的 serialize () 函数中用 boost::serialization::base_object () 函数访问基类实现的。 在例子中强制要求使用这个函数而不是 static_cast 是因为只有 boost::serialization::base_object () 才能保证正确地序列化。

动态创建对象的地址可以被赋值给对应的基类类型的指针。 下面的例子演示了 Boost.Serialization 还能够正确地序列化它们。

#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/serialization/string.hpp> 
#include <boost/serialization/export.hpp> 
#include <iostream> 
#include <sstream> 
#include <string> 

std::stringstream ss; 

class person 
{ 
public: 
  person() 
  { 
  } 

  person(int age) 
    : age_(age) 
  { 
  } 

  virtual int age() const 
  { 
    return age_; 
  } 

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

  template <typename Archive> 
  void serialize(Archive &ar, const unsigned int version) 
  { 
    ar & age_; 
  } 

  int age_; 
}; 

class developer 
  : public person 
{ 
public: 
  developer() 
  { 
  } 

  developer(int age, const std::string &language) 
    : person(age), language_(language) 
  { 
  } 

  std::string language() const 
  { 
    return language_; 
  } 

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

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

  std::string language_; 
}; 

BOOST_CLASS_EXPORT(developer) 

void save() 
{ 
  boost::archive::text_oarchive oa(ss); 
  person *p = new developer(31, "C++"); 
  oa << p; 
  delete p; 
} 

void load() 
{ 
  boost::archive::text_iarchive ia(ss); 
  person *p; 
  ia >> p; 
  std::cout << p->age() << std::endl; 
  delete p; 
} 

int main() 
{ 
  save(); 
  load(); 
}

应用程序在 save () 函数创建了 developer 类型的对象并赋值给 person* 类型的指针，接下来通过 << 序列化。
为了让 Boost.Serialization 识别将要序列化的 developer 类型的对象，即使指针是 person* 类型的对象。 developer 类需要相应的声明。 这是通过这个 BOOST_CLASS_EXPORT 宏实现的，它定义在 boost/serialization/export.hpp 文件中。 因为 developer 这个数据类型没有指针形式的定义，所以 Boost.Serialization 没有这个宏就不能正确地序列化 developer 。
如果子类对象需要通过基类的指针序列化，那么 BOOST_CLASS_EXPORT 宏必须要用。

由于静态注册的原因， BOOST_CLASS_EXPORT 的一个缺点是可能有些注册的类最后是不需要序列化的。 Boost.Serialization 为这种情况提供一种解决方案。

#include <boost/archive/text_oarchive.hpp> 
#include <boost/archive/text_iarchive.hpp> 
#include <boost/serialization/string.hpp> 
#include <boost/serialization/export.hpp> 
#include <iostream> 
#include <sstream> 
#include <string> 

std::stringstream ss; 

class person 
{ 
public: 
  person() 
  { 
  } 

  person(int age) 
    : age_(age) 
  { 
  } 

  virtual int age() const 
  { 
    return age_; 
  } 

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

  template <typename Archive> 
  void serialize(Archive &ar, const unsigned int version) 
  { 
    ar & age_; 
  } 

  int age_; 
}; 

class developer 
  : public person 
{ 
public: 
  developer() 
  { 
  } 

  developer(int age, const std::string &language) 
    : person(age), language_(language) 
  { 
  } 

  std::string language() const 
  { 
    return language_; 
  } 

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

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

  std::string language_; 
}; 

void save() 
{ 
  boost::archive::text_oarchive oa(ss); 
  oa.register_type<developer>(); 
  person *p = new developer(31, "C++"); 
  oa << p; 
  delete p; 
} 

void load() 
{ 
  boost::archive::text_iarchive ia(ss); 
  ia.register_type<developer>(); 
  person *p; 
  ia >> p; 
  std::cout << p->age() << std::endl; 
  delete p; 
} 

int main() 
{ 
  save(); 
  load(); 
}

上面的应用程序没有使用 BOOST_CLASS_EXPORT 宏，而是调用了 register_type () 模板函数。 需要注册的类型作为模板参数传入。
请注意 register_type () 必须在 save () 和 load () 都要调用。
register_type () 的优点是只有需要序列化的类才注册。 比如在开发一个库时，你不知道开发人员将来要序列化哪些类。 当然 BOOST_CLASS_EXPORT 宏用起来简单，可它却可能注册那些不需要序列化的类型。

为了为了在编译时注册类型信息，以便于运行时进行类型反射（type reflection）和序列化支持，确保类型可以在不同模块之间正确地导出、导入，并且能够在运行时被识别和处理，需要做如下处理：

#define TYPE_REFLECT_REGISTER(T, K)                             \
static type_reflect_register<T> g_type_reflect_register_##K;     \

#define REGISTER_TYPE_HEADER(T, K)                  \
  FORCE_EXPORT_HEADER(export_##K##_symbol) \
  BOOST_CLASS_EXPORT_KEY2(T, #K)                             \
  /**/

#define REGISTER_TYPE_SOURCE(T, K)                  \
  FORCE_EXPORT_SOURCE(export_##K##_symbol) \
  BOOST_CLASS_EXPORT_IMPLEMENT(T)                            \
  TYPE_REFLECT_REGISTER(T, K)                                \

TYPE_REFLECT_REGISTER(T, K)
作用：这个宏创建了一个静态对象 g_type_reflect_register_##K，其类型为 type_reflect_register。这个对象会在程序启动时自动构造，从而触发某种形式的类型注册机制。
目的：通过这种方式，可以在全局范围内注册类型 T，使得它可以在运行时被识别。这里的 K 通常是一个唯一的标识符，用于区分不同的注册实例。

REGISTER_TYPE_HEADER(T, K)
作用：FORCE_EXPORT_HEADER 确保符号在头文件中被正确导出，以便链接器可以找到该类型的定义。
BOOST_CLASS_EXPORT_KEY2(T, #K) 是 Boost.Serialization 提供的一个宏，用于为类 T 分配一个唯一的关键字（这里是 #K，即字符串化的 K）。这有助于在多个库或模块之间唯一标识类型 T。

REGISTER_TYPE_SOURCE(T, K)
作用：FORCE_EXPORT_SOURCE 确保符号在源文件中被正确导出，以便链接器可以找到该类型的实现。
BOOST_CLASS_EXPORT_IMPLEMENT(T) 实现了之前由 BOOST_CLASS_EXPORT_KEY2 声明的导出逻辑。它告诉 Boost.Serialization 如何实际导出类型 T 的序列化信息。
TYPE_REFLECT_REGISTER(T, K) 再次调用以确保类型 T 在运行时被注册到类型反射系统中。

这三个宏共同工作，实现了以下功能：
类型注册：确保每个类型 T 都有一个唯一的标识符 K，并且可以在运行时被识别和处理。
跨模块导出/导入：通过 BOOST_CLASS_EXPORT_KEY2 和 BOOST_CLASS_EXPORT_IMPLEMENT，保证类型 T 的序列化信息能够被正确导出并在其他模块中导入。
强制导出符号：使用FORCE_EXPORT_HEADER 和 FORCE_EXPORT_SOURCE 来确保必要的符号在编译和链接过程中被正确处理，避免符号未定义错误。
这种模式特别适用于需要动态加载模块或插件的应用程序，以及那些依赖于运行时类型信息的框架，如序列化库、RPC 系统等。通过这些宏，开发者可以简化类型注册的过程，同时保持良好的模块化设计。

#include <boost/iostreams/stream.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/export.hpp>
#include <iostream>
#include <sstream>
#include <string>

using namespace boost::iostreams;
using namespace boost::archive;

#ifdef _WIN32

#define FORCE_EXPORT_HEADER(name)    \
__pragma(comment(linker, "/export:_"#name)) \

#define FORCE_EXPORT_SOURCE(name) \
    extern "C" void name() {}                \

#else

#define FORCE_EXPORT_HEADER(name)    \
    //__pragma(comment(linker, "/export:_"#name))

#define FORCE_EXPORT_SOURCE(name) \
extern "C" void name() {}

#endif


#define REGISTER_TYPE_HEADER(T, K)                  \
    FORCE_EXPORT_HEADER(export_##K##_symbol) \
    BOOST_CLASS_EXPORT_KEY2(T, #K)                             \
/**/

#define REGISTER_TYPE_SOURCE(T, K)                  \
    FORCE_EXPORT_SOURCE(export_##K##_symbol) \
    BOOST_CLASS_EXPORT_IMPLEMENT(T)                            \


class person
{
public:
    person()
    {
    }

    person(int age)
        : age_(age)
    {
    }

    int age() const
    {
        return age_;
    }

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

    template <typename Archive>
    void serialize(Archive &ar, const unsigned int version)
    {
        ar & age_;
    }

    int age_;
};

class developer
    : public person
{
public:
    developer()
    {
    }

    developer(int age, const std::string &language)
        : person(age), language_(language)
    {
    }

    std::string language() const
    {
        return language_;
    }

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

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

    std::string language_;
};
using developerPtr = std::shared_ptr<developer>;

std::vector<char> pack(const developer& serializable) {
    try {
        std::vector<char> data;
        stream<back_insert_device<std::vector<char>>> stream(data);
        binary_oarchive archive(stream, no_header | no_codecvt);
        const developer* pSerializable = &serializable;
        archive << pSerializable;
        stream.flush();
        return data;
    }
    catch (const archive_exception& e) {
        printf("serialization::pack failed:%s\n", e.what());
        return {};
    }
}

REGISTER_TYPE_HEADER(developer, developer);
REGISTER_TYPE_SOURCE(developer, developer);

developerPtr unpack(const std::vector<char>& data) {
    try {
        stream<array_source> stream(array_source{ data.data(), data.size() });
        binary_iarchive archive(stream, no_header | no_codecvt);
        developer* serializable;
        archive & serializable;
        return developerPtr(serializable);
    }
    catch (const archive_exception&) {
        return nullptr;
    }
}

int main()
{
    developer d(31, "C++");
    std::vector<char> vDatas = pack(d);
    developerPtr dptr = unpack(vDatas);

    std::cout << "language:" << dptr->language() << ", age:" << dptr->age() << std::endl;

}

参考文档：
http://zh.highscore.de/cpp/boost/serialization.html

时间序列预测 — 时间序列预测研究综述
几度春风里的博客
11-10 1万+
指对某种事物发展变化过程进行观测并按照一定频率采集得出的一组随机变量。就是从众多数据中挖掘出其蕴含的核心规律并且依据已知的因素对未来的数据做出准确的估计。由于大量物联网数据采集设备的接入、多维数据的爆炸增长和对预测精度的要求愈发苛刻，经典的参数模型以及传统机器学习算法难以满足预测任务的高效率和高精度需求。近年来，以卷积神经网络、循环神经网络和 Transformer模型为代表的深度学习算法在时间序列预测任务中取得了丰硕的成果。
【项目】Boost 搜索引擎
最新发布
StackFrame
08-26 1529
Boost 搜索引擎
boost -- 序列化（serialize）
There is an octopus in the fish pond
09-16 2171
本篇文字主要来记录学习使用boost进行序列化 介绍 实例 序列化成普通文本 非侵入式 // C #include <stdlib.h> #include <stdio.h> // C++ #include <fstream> #include <string> // boost #include <boost/archive/text_iarchive.hpp> #include <boost/archive/text_oarchi
Boost - 序列化 (Serialization)
热门推荐
zj510的专栏
10-24 4万+
程序开发中，序列化是经常需要用到的。像一些相对高级语言，比如JAVA, C#都已经很好的支持了序列化，那么C++呢？当然一个比较好的选择就是用Boost，这个号称C++准标准库的东西。 什么时候需要序列化呢？举个例子，我们定义了一个class，比如： class CCar { public: void SetName(std::string& strName){m_strName = str
Boost 序列化
一个为生活而拼搏的女人
12-19 2026
没有工作前，不知道序列化的作用。虽然那时候学习《Programming with MFC》的时候，也知道CArchive，CObject等东西，但是没有太意识到其作用。但是，如前所述，我工作的第一件事情，就是了解公司的序列化 类。从当时的一无所知，到现在也慢慢理解了一些序列化的作用了。说起来，自从工作以来因为当时做文件系统后后来的程序补丁，我应经在公司的序列化类以外额 外实现了两个独立的序列化类了
C++Boost的序列化
LuckyStar的博客
03-09 1863
date;侵入式版本{}{}return out;} date;date dr;序列化版本控制123public:CPerson();;~CPerson();private://要想序列化用户定义的类型 必须定义seriallze函数//serialzation不应该被显示调用 因为它仅在序列化或者反序列化的时候调用。
boost 序列化
是我
11-23 350
#include #include std::stringstream strstream; void save() { boost::archive::text_oarchive oa(strstream); int i = 1; oa << i; //将i的值序列化到strstream 类中 TRACE("%s\n",strstream.str().c_st
【C++11】C++11 序列化库 cereal----- 未消化，待学习
小鱼菜鸟的博客
08-27 407
cereal —— C++11 序列化库 介绍 cereal是一个只包含头文件的C++序列化库，cereal支持任何类型的数据并可以将其序列化为不同形式，例如：二进制、XML或者JSON。 cereal的设计理念是快速、轻量级和容易扩展——cereal没有依赖第三库而且可以轻易的将其和其他代码相。 cereal 完整支持 C++11 cerea...
CatBoost推荐系统使用：个性化推荐的4大秘诀
CatBoost推荐系统的概览 ## 1.1 推荐系统的发展背景 推荐系统作为信息过载时代的导航灯塔，极大地改善了用户的在线体验。从在线零售到社交媒体，再到音乐和视频流媒体服务，推荐系统无处不在。随着机器学习技术的...
《Boost程序完全开发指南》
JUSTACES 的博客
01-27 9111
1.3开发环境 由于Boost大量使用了C++高级特性（如模板偏特化、ADL），因此不是所有的编译器都 能够很好地支持Boost。 在VC集成环境中使用嵌入工程编译的方式需要定义宏BOOST_ALL_NO_LIB或者 BOOST_XXX_NO_LIB(XXX是某个库的名称)，以指示BOOST库不要使用自动链接功能。 如果在debug版工程，不要忘记在Preprocesso
C++11 下使用 Boost.Serialization 库实现智能指针的序列化
12-07
C++11 下使用 Boost.Serialization 库实现智能指针的序列化
Boost序列化
04-06
Boost序列化.C++对象到磁盘，已解决内存不足的问题
boost类序列化
06-19
boost类序列化
boost序列化
yinhaijing123的专栏
09-12 1237
Boost C++ 库 导言第 1 章 简介 第 2 章 智能指针第 3 章 函数对象 第 4 章 事件处理第 5 章 字符串处理 第 6 章 多线程第 7 章 异步输入输出 第 8 章 进程间通讯第 9 章 文件系统 第 10 章 日期与时间第 11 章 序列化 第 12 章 词法分析器 第 13 章 容器第 14 章 数据结构 第 15 章 错误处理第 16 章 类型
Boost serialization
freehyan的博客
07-03 3244
序列化(serializtion)是指把对象信息转换成可以存储或者通过网络连接传输格式的过程，然后在本地或者在另一个计算机环境中可以重构出原有的对象信息是指反序列化。前言本文只介绍通过boost serialization存储的优势，先通过例子简单明白。假如现在你是一个学校学生系统管理员，你需要保存学生信息，比如学生学好，名字，年龄。当然最简单的方式是通过C++的文本操作解决方案。//*******
boost serialization
weixin_30632899的博客
08-13 171
Archive An archive is a sequence of bytes that represented serialized C++ objects. Objects can be added to an archive to serialize them and then later loaded from the archive. 1. boost::archive...
Boost学习之序列化
lvchang
05-30 528
序列化是指将任意的C++数据结构可逆的解构到字节流中。序列化之后我们就可以实现对象的持久化，网络传输，远程参数传递等。序列化在网络传输中是非常重要的。 在定义网络结构包时，我们可能通常会以以下方式去处理序列化问题，如： class CBasePacket { ... ... public: virtual void readFromBuffer(const char* pBuffer)=0; virtual void writeToBuffer(char* pBufffer)=0;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值