1.　　　　　 非介入式版本

　　感觉实际使用中我还没有碰到过，既然需要完全的public才能还原数据，那么介入不介入好像影响也不大了，除非碰到一个东西是别的公司写的，不让改，我是还没有碰到这样的情况。

　　从这里开始见识Boost序列化库的强大。

　　2.　　　　　 指针的序列化：

　　下面的例子为文档中例子的简化，并添加必要部分以方便运行及演示。

//　BoostLearn.cpp　:　定义控制台应用程序的入口点。
//
　
#include　"stdafx.h"
　
#include　<fstream>
　
//　包含以简单文本格式实现存档的头文件
#include　<boost/archive/text_oarchive.hpp>
#include　<boost/archive/text_iarchive.hpp>
　
/////////////////////////////////////////////////////////////
//　gps　座标
//
//　举例说明简单类型的序列化
//
class　gps_position
{
private:
　　　　friend　class　boost::serialization::access;
　　　　//　如果类Archive　是一个输出存档，则操作符&　被定义为<<.　　同样，如果类Archive
　　　　//　是一个输入存档，则操作符&　被定义为>>.
　　　　template<class　Archive>
　　　　void　serialize(Archive　&　ar,　const　unsigned　int　version)
　　　　{
　　　　　　　ar　&　degrees;
　　　　　　　ar　&　minutes;
　　　　　　　ar　&　seconds;
　　　　}
　　　　int　degrees;
　　　　int　minutes;
　　　　float　seconds;
public:
　　　　gps_position()
　　　　{
　　　　　　　degrees　=　0;
　　　　　　　minutes　=　0;
　　　　　　　seconds　=　0.0;
　　　　};
　　　　gps_position(int　d,　int　m,　float　s)　:
　　　　degrees(d),　minutes(m),　seconds(s)
　　　　{}
};
　
class　bus_stop
{
　　　　friend　class　boost::serialization::access;
　　　　template<class　Archive>
　　　　void　serialize(Archive　&　ar,　const　unsigned　int　version)
　　　　{
　　　　　　　ar　&　latitude;
　　　　　　　ar　&　longitude;
　　　　}
　
　　　　gps_position　latitude;
　　　　gps_position　longitude;
public:
　　　　bus_stop(){　}
　　　　bus_stop(const　gps_position　&　lat_,　const　gps_position　&　long_)　:
　　　　　　　　latitude(lat_),　longitude(long_){　}
　　　　　　　　
　　　　virtual　~bus_stop(){　}
};
　
class　bus_stop_corner　:　public　bus_stop
{
　　　　friend　class　boost::serialization::access;
　　　　template<class　Archive>
　　　　void　serialize(Archive　&　ar,　const　unsigned　int　version)
　　　　{
　　　　　　　//　序列化基类信息
　　　　　　　ar　&　boost::serialization::base_object<bus_stop>(*this);
　　　　　　　ar　&　street1;
　　　　　　　ar　&　street2;
　　　　}
　　　　std::string　street1;
　　　　std::string　street2;
　
public:
　　　　bus_stop_corner(){}
　　　　bus_stop_corner(const　gps_position　&　lat_,　const　gps_position　&　long_,
　　　　　　　const　std::string　&　s1_,　const　std::string　&　s2_
　　　　　　　)　:
　　　　bus_stop(lat_,　long_),　street1(s1_),　street2(s2_)
　　　　{}
　
　　　　virtual　std::string　description()　const
　　　　{
　　　　　　　return　street1　+　"　and　"　+　street2;
　　　　}
};
　
　
class　bus_route
{
　　　　friend　class　boost::serialization::access;
　　　　bus_stop_corner　*　stops[2];
　　　　template<class　Archive>
　　　　void　serialize(Archive　&　ar,　const　unsigned　int　version)
　　　　{
　　　　　　　int　i;
　　　　　　　for(i　=　0;　i　<　2;　++i)
　　　　　　　　　　　ar　&　stops[i];
　　　　}
public:
　　　　bus_route(bus_stop_corner　*apStop1,　bus_stop_corner　*apStop2)
　　　　{
　　　　　　　stops[0]　=　apStop1;
　　　　　　4stops[1]　=　apStop2;
　　　　}
　　　　bus_route(){}
};
　
　
　
int　main()　{
　　　　//　创建并打开一个输出用的字符存档
　　　　std::ofstream　ofs("bus_route");
　
　　　　//　创建类实例
　　　　const　gps_position　latitude(1,　2,　3.3f);
　　　　const　gps_position　longitude(4,　5,　6.6f);
　
　　　　bus_stop_corner　*lpStop1　=　new　bus_stop_corner(latitude,　longitude,　"corn1",　"corn2");
　　　　bus_stop_corner　*lpStop2　=　new　bus_stop_corner(latitude,　longitude,　"corn3",　"corn4");
　
　　　　bus_route　route(lpStop1,　lpStop2);
　
　　　　//　保存数据到存档
　　　　{
　　　　　　　boost::archive::text_oarchive　oa(ofs);
　　　　　　　//　将类实例写出到存档
　　　　　　　oa　<<　route;
　　　　　　　//　在调用析构函数时将关闭存档和流
　　　　}
　
　　　　//　...　晚些时候，将类实例恢复到原来的状态
　　　　bus_route　new_route;
　　　　{
　　　　　　　//　创建并打开一个输入用的存档
　　　　　　　std::ifstream　ifs("bus_route",　std::ios::binary);
　　　　　　　boost::archive::text_iarchive　ia(ifs);
　　　　　　　//　从存档中读取类的状态
　　　　　　　ia　>>　new_route;
　　　　　　　//　在调用析构函数时将关闭存档和流
　　　　}
　
　　　　delete　lpStop1;
　　　　delete　lpStop2;
　　　　return　0;
}

编缉推荐阅读以下文章

• 序列化支持(3)—Boost的序列化库的使用
• 序列化支持(2)—Boost的序列化库
• 序列化支持(1)—前言