• 【BOOST C++ 19 应用库】（3）Boost.Archive

    一、说明

            对Boost.Serialization库的应用，存在如下内容：

            Boost.Serialization 库可以将 C++ 程序中的对象转换为可以保存和加载以恢复对象的字节序列。有不同的数据格式可用于定义生成字节序列的规则。 Boost.Serialization 支持的所有格式仅适用于此库。例如，为 Boost.Serialization 开发的 XML 格式不应用于与不使用 Boost.Serialization 的程序交换数据。 XML 格式的唯一优点是它可以使调试更容易，因为 C++ 对象以可读格式保存。

    二、关于Archive库

            Boost.Serialization 的主要概念是存档。存档是表示序列化 C++ 对象的字节序列。可以将对象添加到存档中以对其进行序列化，然后再从存档中加载。为了恢复以前保存的 C++ 对象，假定相同的类型。

            示例 64.1。使用 boost::archive::text_oarchive

    1. #include 
    2. #include 
    3.  
    4. using namespace boost::archive;
    5.  
    6. int main()
    7. {
    8.   text_oarchive oa{std::cout};
    9.   int i = 1;
    10.   oa << i;
    11. }

            Boost.Serialization 提供归档类，例如 boost::archive::text_oarchive，它在 boost/archive/text_oarchive.hpp 中定义。此类可以将对象序列化为文本流。使用 Boost 1.56.0，示例 64.1 将 22 serialization::archive 11 1 写入标准输出流。

            可以看出，boost::archive::text_oarchive 类型的对象 oa 可以像流一样使用 operator<< 序列化变量。但是，不应将存档视为存储任意数据的常规流。要恢复数据，您必须在存储数据时访问它，并以相同的顺序使用相同的数据类型。示例 64.2 序列化并恢复一个 int 类型的变量。

            示例 64.2。使用 boost::archive::text_iarchive

    1. #include <boost/archive/text_oarchive.hpp>
    2. #include <boost/archive/text_iarchive.hpp>
    3. #include <iostream>
    4. #include <fstream>
    5.  
    6. using namespace boost::archive;
    7.  
    8. void save()
    9. {
    10.   std::ofstream file{"archive.txt"};
    11.   text_oarchive oa{file};
    12.   int i = 1;
    13.   oa << i;
    14. }
    15.  
    16. void load()
    17. {
    18.   std::ifstream file{"archive.txt"};
    19.   text_iarchive ia{file};
    20.   int i = 0;
    21.   ia >> i;
    22.   std::cout << i << '\n';
    23. }
    24.  
    25. int main()
    26. {
    27.   save();
    28.   load();
    29. }

            boost::archive::text_oarchive 类将数据序列化为文本流，而 boost::archive::text_iarchive 类从此类文本流中恢复数据。要使用这些类，请包含头文件 boost/archive/text_iarchive.hpp 和 boost/archive/text_oarchive.hpp。

            档案的构造函数期望输入或输出流作为参数。流用于序列化或恢复数据。虽然示例 64.2 访问文件，但也可以使用其他流，例如字符串流。

            示例 64.3。使用字符串流序列化

    1. #include <boost/archive/text_oarchive.hpp>
    2. #include <boost/archive/text_iarchive.hpp>
    3. #include <iostream>
    4. #include <sstream>
    5.  
    6. using namespace boost::archive;
    7.  
    8. std::stringstream ss;
    9.  
    10. void save()
    11. {
    12.   text_oarchive oa{ss};
    13.   int i = 1;
    14.   oa << i;
    15. }
    16.  
    17. void load()
    18. {
    19.   text_iarchive ia{ss};
    20.   int i = 0;
    21.   ia >> i;
    22.   std::cout << i << '\n';
    23. }
    24.  
    25. int main()
    26. {
    27.   save();
    28.   load();
    29. }

    Example 64.3

    示例 64.3 使用字符串流将 1 写入标准输出以序列化数据。

    到目前为止，只有原始类型被序列化。示例 64.4 显示了如何序列化用户定义类型的对象。

    示例 64.4。使用成员函数序列化用户定义的类型

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace boost::archive;
    7.  
    8. std::stringstream ss;
    9.  
    10. class animal
    11. {
    12. public:
    13.   animal() = default;
    14.   animal(int legs) : legs_{legs} {}
    15.   int legs() const { return legs_; }
    16.  
    17. private:
    18.   friend class boost::serialization::access;
    19.  
    20.   template <typename Archive>
    21.   void serialize(Archive &ar, const unsigned int version) { ar & legs_; }
    22.  
    23.   int legs_;
    24. };
    25.  
    26. void save()
    27. {
    28.   text_oarchive oa{ss};
    29.   animal a{4};
    30.   oa << a;
    31. }
    32.  
    33. void load()
    34. {
    35.   text_iarchive ia{ss};
    36.   animal a;
    37.   ia >> a;
    38.   std::cout << a.legs() << '\n';
    39. }
    40.  
    41. int main()
    42. {
    43.   save();
    44.   load();
    45. }

            为了序列化用户定义类型的对象，您必须定义成员函数 serialize()。当对象被序列化为字节流或从字节流恢复时调用此函数。因为 serialize() 用于序列化和恢复，所以除了 operator<< 和 operator>> 之外，Boost.Serialization 还支持运算符 operator&。使用 operator& 时，无需在 serialize() 中区分序列化和恢复。

            序列化或恢复对象时，会自动调用 serialize()。它永远不应该被显式调用，因此应该被声明为私有的。如果声明为私有，则必须将类 boost::serialization::access 声明为友元，以允许 Boost.Serialization 访问成员函数。

            可能存在不允许修改现有类以添加 serialize() 的情况。例如，标准库中的类就是如此。

            示例 64.5。使用独立函数序列化

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. using namespace boost::archive;
    7.  
    8. std::stringstream ss;
    9.  
    10. struct animal
    11. {
    12.   int legs_;
    13.  
    14.   animal() = default;
    15.   animal(int legs) : legs_{legs} {}
    16.   int legs() const { return legs_; }
    17. };
    18.  
    19. template <typename Archive>
    20. void serialize(Archive &ar, animal &a, const unsigned int version)
    21. {
    22.   ar & a.legs_;
    23. }
    24.  
    25. void save()
    26. {
    27.   text_oarchive oa{ss};
    28.   animal a{4};
    29.   oa << a;
    30. }
    31.  
    32. void load()
    33. {
    34.   text_iarchive ia{ss};
    35.   animal a;
    36.   ia >> a;
    37.   std::cout << a.legs() << '\n';
    38. }
    39.  
    40. int main()
    41. {
    42.   save();
    43.   load();
    44. }

            为了序列化不能修改的类型，可以定义独立函数 serialize()，如示例 64.5 所示。此函数需要对相应类型的对象的引用作为其第二个参数。

            将 serialize() 作为独立函数实现需要可以从外部访问类的基本成员变量。在示例 64.5 中，serialize() 只能作为独立函数实现，因为 legs_ 不再是动物类的私有成员变量。

            Boost.Serialization 为标准库中的许多类提供了 serialize() 函数。要序列化基于标准类的对象，需要包含额外的头文件。

            示例 64.6。序列化字符串

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. using namespace boost::archive;
    10.  
    11. std::stringstream ss;
    12.  
    13. class animal
    14. {
    15. public:
    16.   animal() = default;
    17.   animal(int legs, std::string name) :
    18.     legs_{legs}, name_{std::move(name)} {}
    19.   int legs() const { return legs_; }
    20.   const std::string &name() const { return name_; }
    21.  
    22. private:
    23.   friend class boost::serialization::access;
    24.  
    25.   template <typename Archive>
    26.   friend void serialize(Archive &ar, animal &a, const unsigned int version);
    27.  
    28.   int legs_;
    29.   std::string name_;
    30. };
    31.  
    32. template <typename Archive>
    33. void serialize(Archive &ar, animal &a, const unsigned int version)
    34. {
    35.   ar & a.legs_;
    36.   ar & a.name_;
    37. }
    38.  
    39. void save()
    40. {
    41.   text_oarchive oa{ss};
    42.   animal a{4, "cat"};
    43.   oa << a;
    44. }
    45.  
    46. void load()
    47. {
    48.   text_iarchive ia{ss};
    49.   animal a;
    50.   ia >> a;
    51.   std::cout << a.legs() << '\n';
    52.   std::cout << a.name() << '\n';
    53. }
    54.  
    55. int main()
    56. {
    57.   save();
    58.   load();
    59. }

    Example 64.6

            示例 64.6 通过添加 name_ 扩展类 animal，这是一个 std::string 类型的成员变量。为了序列化此成员变量，必须包含头文件 boost/serialization/string.hpp 以提供适当的独立函数 serialize()。

            如前所述，Boost.Serialization 为标准库中的许多类定义了 serialize() 函数。这些函数在头文件中定义，这些头文件的名称与标准中相应的头文件相同。因此，要序列化 ​​std::string 类型的对象，请包含头文件 boost/serialization/string.hpp，要序列化 ​​std::vector 类型的对象，请包含头文件 boost/serialization/vector.hpp。要包含哪个头文件是相当明显的。

            到目前为止被忽略的 serialize() 的一个参数是版本。此参数有助于使存档向后兼容。示例 64.7 可以加载由示例 64.5 创建的存档。示例 64.5 中动物类的版本不包含名称。示例 64.7 在加载存档时检查版本号，并且仅在版本大于 0 时才访问名称。这允许它处理创建时没有名称的旧存档。

            示例 64.7。与版本号的向后兼容性

    1. #include <boost/archive/text_oarchive.hpp>
    2. #include <boost/archive/text_iarchive.hpp>
    3. #include <boost/serialization/string.hpp>
    4. #include <iostream>
    5. #include <sstream>
    6. #include <string>
    7. #include <utility>
    8.  
    9. using namespace boost::archive;
    10.  
    11. std::stringstream ss;
    12.  
    13. class animal
    14. {
    15. public:
    16.   animal() = default;
    17.   animal(int legs, std::string name) :
    18.     legs_{legs}, name_{std::move(name)} {}
    19.   int legs() const { return legs_; }
    20.   const std::string &name() const { return name_; }
    21.  
    22. private:
    23.   friend class boost::serialization::access;
    24.  
    25.   template <typename Archive>
    26.   friend void serialize(Archive &ar, animal &a, const unsigned int version);
    27.  
    28.   int legs_;
    29.   std::string name_;
    30. };
    31.  
    32. template <typename Archive>
    33. void serialize(Archive &ar, animal &a, const unsigned int version)
    34. {
    35.   ar & a.legs_;
    36.   if (version > 0)
    37.     ar & a.name_;
    38. }
    39.  
    40. BOOST_CLASS_VERSION(animal, 1)
    41.  
    42. void save()
    43. {
    44.   text_oarchive oa{ss};
    45.   animal a{4, "cat"};
    46.   oa << a;
    47. }
    48.  
    49. void load()
    50. {
    51.   text_iarchive ia{ss};
    52.   animal a;
    53.   ia >> a;
    54.   std::cout << a.legs() << '\n';
    55.   std::cout << a.name() << '\n';
    56. }
    57.  
    58. int main()
    59. {
    60.   save();
    61.   load();
    62. }

            宏 BOOST_CLASS_VERSION 为类分配版本号。示例 64.7 中类动物的版本号为 1。如果未使用 BOOST_CLASS_VERSION，版本号默认为 0。

            版本号存储在存档中并且是其中的一部分。虽然在序列化期间使用通过 BOOST_CLASS_VERSION 宏为特定类指定的版本号，但在恢复时将 serialize() 的参数版本设置为存储在存档中的值。如果新版本的 animal 访问包含用旧版本序列化的对象的存档，则成员变量 name_ 不会被恢复，因为旧版本没有这样的成员变量。

            练习
            创建一个程序，将 std::runtime_error 类型的对象序列化为一个文件并再次加载它。

  • 相关阅读:
    新品速看丨创新微MinewSemi正式推出GNSS高精度卫星定位导航模块
    Ubuntu输入正确密码重新跳到登录界面
    Yolo v8数据马赛克数据增强代码详解
    Flutter快速入门学习（一）
    R语言使用purrr包的pmap函数或者map2函数来向量化普通标量函数来处理向量数据、计算两个向量之间的按元素的最大公约数GCD
    数据结构与算法基础-学习-05-线性表之链式表-删除元素、头插法创建单链表、尾插法创建单链表等实现
    如何构建 API 生态促进企业上下游合作
    Two-Stream Consensus Network论文阅读
    Unity UGUI Image Maskable
    开发笔记 —— Centos7 在急救模式下修改密码
  • 原文地址：https://blog.csdn.net/gongdiwudu/article/details/128060954