下面看一个简单的例子。

    Boost.Serialization 提供了多个归档类,如 类,它定义在 boost/archive/text_oarchive.hpp 文件中。 boost::archive::text_oarchive,可将对象序列化为文本流。 上面的应用程序将 22 serialization::archive 5 1 写出到标准输出流。

    可见, boost::archive::textoarchive 类型的对象 _oa 可以用来像流 (stream) 一样通过 << 来序列化对象。 尽管如此,归档也不能被认为是可以存储任何数据的常规的流。 为了以后恢复数据,必须以相同的顺序使用和先前存储时用的一样的数据类型。 下面的例子序列化和恢复了 int 类型的变量。

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

    boost::archive::text_oarchive 被用来把数据序列化为文本流, boost::archive::text_iarchive 就用来从文本流恢复数据。 为了使用这些类,必须包含 boost/archive/text_iarchive.hpp 头文件。

    归档的构造函数需要一个输入或者输出流作为参数。 流分别用来序列化或恢复数据。 虽然上面的应用程序使用了一个文件流,其他流,如 stringstream 流也是可以的。

    到目前为止, 原始的数据类型已经被序列化了。 接下来的例子演示如何序列化用户定义类型的对象。

    1. #include <boost/archive/text_oarchive.hpp>
    2. #include <boost/archive/text_iarchive.hpp>
    3. #include <iostream>
    4. #include <sstream>
    5.  
    6. std::stringstream ss;
    7.  
    8. class person
    9. {
    10. public:
    11. person()
    12. {
    13. }
    14.  
    15. person(int age)
    16. : age_(age)
    17. {
    18. }
    19.  
    20. int age() const
    21. {
    22. return age_;
    23.  
    24. private:
    25. friend class boost::serialization::access;
    26.  
    27. template <typename Archive>
    28. void serialize(Archive &ar, const unsigned int version)
    29. {
    30. ar & age_;
    31. }
    32.  
    33. int age_;
    34. };
    35.  
    36. void save()
    37. {
    38. boost::archive::text_oarchive oa(ss);
    39. person p(31);
    40. oa << p;
    41. }
    42.  
    43. void load()
    44. {
    45. boost::archive::text_iarchive ia(ss);
    46. person p;
    47. ia >> p;
    48. std::cout << p.age() << std::endl;
    49. }
    50.  
    51. int main()
    52. {
    53. save();
    54. load();
    55. }
    56.  

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

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

    有些情况下需要添加 serialize() 函数却不能修改现有的类。 比如,对于来自 C++ 标准库或其他库的类就是这样的。

    为了序列化那些不能被修改的数据类型,要定义一个单独的函数 serialize(),如上面的例子所示。 这个函数需要相应的数据类型的引用作为它的第二个参数。

    不过还好,Boost.Serialization 为许多C++标准库的类提供了 serialize() 函数。 为了序列化基于 C++ 标准库的类,需要包含额外的头文件。

    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.  
    8. std::stringstream ss;
    9.  
    10. class person
    11. {
    12. public:
    13. person()
    14. {
    15. }
    16.  
    17. person(int age, const std::string &name)
    18. {
    19. }
    20.  
    21. int age() const
    22. {
    23. return age_;
    24. }
    25.  
    26. std::string name() const
    27. {
    28. return name_;
    29. }
    30.  
    31. private:
    32. friend class boost::serialization::access;
    33.  
    34. template <typename Archive>
    35. friend void serialize(Archive &ar, person &p, const unsigned int version);
    36.  
    37. int age_;
    38. std::string name_;
    39. };
    40.  
    41. template <typename Archive>
    42. void serialize(Archive &ar, person &p, const unsigned int version)
    43. {
    44. ar & p.age_;
    45. ar & p.name_;
    46. }
    47.  
    48. void save()
    49. {
    50. boost::archive::text_oarchive oa(ss);
    51. person p(31, "Boris");
    52. oa << p;
    53. }
    54.  
    55. void load()
    56. {
    57. boost::archive::text_iarchive ia(ss);
    58. person p;
    59. ia >> p;
    60. std::cout << p.age() << std::endl;
    61. std::cout << p.name() << std::endl;
    62. }
    63.  
    64. int main()
    65. {
    66. save();
    67. load();
    68. }
    69.  

    这个例子扩展了 person 类,增加了 std::string 类型的名称变量,为了序列化这个属性property, the header file boost/serialization/string.hpp 头文件必须包含,它提供了合适的单独的 serialize () 函数。

    正如前面所提到的, Boost.Serialization 为许多 C++ 标准库类定义了 函数。 这些都定义在和 C++ 标准库头文件名称相对应的头文件中。 为了序列化 std::string 类型的对象,必须包含 boost/serialization/string.hpp 头文件。 为了序列化 std::vector 类型的对象,必须包含 boost/serialization/vector.hpp 头文件。 于是在给定的场合中应该包含哪个头文件就显而易见了。

    还有一个 serialize ()函数的参数,到目前为止我们一直忽略没谈到,那就是 version 。 如果归档需要向前兼容,以支持给定应用程序的未来版本,那么这个参数就是有意义的。 接下来的例子考虑到 person 类的归档需要向前兼容。由于 person 的原始版本没有包含任何名称,新版本的 person 应该能够处理不带名称的旧的归档。

    BOOST_CLASS_VERSION 宏用来指定类的版本号。 上面例子中 person 类的版本号设置为1。 如果没有使用 BOOST_CLASS_VERSION , 版本号缺省是0。