CSDN博客

img hellwolf

Serialization指南

发表于2005/1/3 15:16:00  3234人阅读

C++ Boost

序列化

Overview


需求
其他实现方案
这里,我们用术语序列化(serialization)来表示将一组原始的C++数据结构表示为字节流达到可逆析构的目的。这样的系统可以用来在另一个程序环境中重新建立原来的数据结构。因此,它也可以作为对象持久性(object persistence),远程参数传递(remote parameter passing),或者其他特性的实现基础。在我们的系统中,将使用术语档案(archive)表示一个具体的字节流。档案可以是二进制文件,文本文件,XML文件,或者其他用户定义的类型。

我们的目标是:

  1. 代码的可移植性--只依靠ANSI C++的特性。
  2. 代码的经济性--挖掘各种C++的特性如RTTI、模板、和多继承等等使用户容易使用并且代码短小。
  3. 类版本的独立性。--当一个类的定义改变时,老版本的类的档案仍然可以被导入新版本的类中。
  4. 指针的深度存储和恢复。--保存或恢复指针的同时保存或恢复指针指向的数据。 
  5. 正确的处理多个指针指向相同对象时的问题。
  6. 对STL和其他常用模板类的序列化的直接支持。 
  7. 数据的可移植性--在一个平台上建立的字节流在另一个平台上也应该是正确的。
  8. 序列化和档案格式的正交性--可以在不改变类的序列化部分时应用任何格式的文件作为档案。
  9. 支持非侵入(Non-intrusive)式的实现。类不需要从某个特定的类派生或者实现特定的成员函数。这对于我们不能或不愿意修改类的定义的情况时是相当必要的。
  10. 档案的接口应该足够简单使建立新类型的档案的工作变得轻松。
  11. 档案应该支持XML格式。

其他实现方案

在开始这项工作之前,我找了一些目前的实现方案
  • MFC 是我非常熟悉的一个实现方案。我已经使用它数年了,而且发现它非常的有用。然而它不符合需求1,2,3,6,7,9。尽管如此,这人是我发现的最有用的实现。另外我发现类版本--MFC中部分的实现了这个特性--的支持在我的程序中是不可或缺的。比如,版本1.x的运输程序常常存储比以前提供的数据更多的信息。MFC是唯一支持版本功能的实现方案--尽管只能用于最晚辈派生类(most derived class)。但有总比没有好。另外MFC不支持STL容器的序列化,它只为MFC容器服务。
  • CommonC++ libraries [1] 这相当接近MFC的实现而且也解决了部分MFC的问题。它是可移植的,它建立可移植的档案但是不支持版本功能。它正确的处理了执政的存储,并且支持STL容器。它也解决了档案的压缩(虽然我不喜欢她的实现方式)。但这个库需要一个更好的文档。它不符合需求2,3,7,8,9。
  • Eternity [2] 这是一个"裸库":-)。它的代码很漂亮但是它确实需要一份好的文档和更多的例子。没有充分的学习他的源代码的话你讲不知道如何去使用它。最新的版本支持XML格式。它不符合需求3,6,7?,8,9。
  • Holub's implementation [3] 它第一个让我认真思考我自己对序列化的需求的实现。你如果不是抱着自大和傲慢的态度的话,读它将是相当有趣和值得的。它不符合需求2,3,4,5,6。
  • s11n [13] 这个库的目标和我们相当接近。一些方面的实现也相当类似。在写这篇文章之时,它的一些问题是:
    • 代码的可移植性(1)。 代码只在最近的GCC版本中可以使用。
    • 类版本的独立性(3)。 类版本不被直接支持。
    • 需求(5).它并没有自动的处理多指针问题。我还从文档中总结出来向图一样的数据结构也不支持。
    它与我们的实现有许多不同也有许多相同的地方。

Revised 1 November, 2004

© Copyright Robert Ramey 2002-2004. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

 

 

Serialization

指南


一个简单的例子
非侵入版本
可以序列化的成员
派生类
指针
数组
STL容器
类的版本化
serializesave/load分开实现
档案

ar << data;
ar & data;
一个输出档案和一个输出流非常像。数据用<<或者&操作符可以存入档案。

ar >> data;
ar & data;
一个输入档案和输出流也很相似。用>>和&操作符可以从档案中获得数据。

当这些操作符用于基本数据类型时,数据简单的存储进档案/从档案中载入。当用于类类型数据时,类的serialize函数就被调用。每个serialize 函数都通过上面的那些操作符来存储和载入类的数据成员。这是一个递归的过程,直到所有的所有的存储/载入工作都已经完成。

一个简单的例子

<<和&操作符在 serialize 函数内部用来存储和载入类的数据成员。

demo.cpp 演示了如何使用我们的系统。下面摘录的代码用最简单的例子演示这个库应该被如何使用。


#include <fstream>

// include headers that implement a archive in simple text format
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

/////////////////////////////////////////////////////////////
// gps coordinate
//
// illustrates serialization for a simple type
//
class gps_position
{
private:
    friend class boost::serialization::access;
    // When the class Archive corresponds to an output archive, the
    // & operator is defined similar to <<.  Likewise, when the class Archive
    // is a type of input archive the & operator is defined similar to >>.
    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(){};
    gps_position(int d, int m, float s) :
        degrees(d), minutes(m), seconds(s)
    {}
};

int main() {
    // create and open a character archive for output
    std::ofstream ofs("filename");
    boost::archive::text_oarchive oa(ofs);

    // create class instance
    const gps_position g(35, 59, 24.567f);
    // write class instance to archive
    oa << g;
    // close archive
    ofs.close();

    // ... some time later restore the class instance to its orginal state
    // create and open an archive for input
    std::ifstream ifs("filename", std::ios::binary);
    boost::archive::text_iarchive ia(ifs);
    // read class state from archive
    gps_position newg;
    ia >> newg;
    // close archive
    ifs.close();
    return 0;
}

任何想通过序列化存储的类都必须有一个函数存储它的成员以表示这个类的状态。相应的,想从序列中获得数据的类必须定义一个函数,这个函数以和存储的次序相同的顺序获得数据。在上面的例子中,这个函数以一个成员模板函数 serialize的形式出现。

非侵入版本

上面的例子用了侵入式的表达方式,也就是类的定义必须为了序列化的要求而作相应的更改。有些情况下这个可能不方便。这个系统中还有一个等价的表达方式:


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

class gps_position
{
public:
    int degrees;
    int minutes;
    float seconds;
    gps_position(){};
    gps_position(int d, int m, float s) :
        degrees(d), minutes(m), seconds(s)
    {}
};

namespace boost {
namespace serialization {

template<class Archive>
void serialize(Archive & ar, gps_position & g, const unsigned int version)
{
    ar & g.degrees;
    ar & g.minutes;
    ar & g.seconds;
}

} // namespace serialization
} // namespace boost

这个例子中serialize函数不再是成员函数。但工作方式几乎和上面的例子中的函数一样。

非侵入主要用于无法改变类的定义又想加入序列化支持的情况下。为了达到这个目的,类必须提供足够的信息和接口来重建类的状态。在这个例子中,我们简单的使用了公有数据成员——这当然很不常见。只有当类提供足够的信息和接口存储和载入类的状态时才能在不改变类的定义的情况下加入序列化的支持。

可以序列化的成员

一个有可序列化成员的可序列化类:


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;
protected:
    bus_stop(const gps_position & lat_, const gps_position & long_) :
    latitude(lat_), longitude(long_)
    {}
public:
    bus_stop(){}
    // See item # 14 in Effective C++ by Scott Meyers.
    // re non-virtual destructors in base classes.
    virtual ~bus_stop(){}
};

可以看到,可序列化成员的序列化方式和基本数据类型没有什么区别。

注意到存储一个bus_stop类也会调用latitude和longitude的 serialize 函数,它在gps_position中定义。 这种方式允许整个数据结构只要通过存储他们的根就可以将所有正确的序列化。

派生类

派生类应该负责调用它们的基类的序列化函数。


#include <boost/serialization/base_object.hpp>

class bus_stop_corner : public bus_stop
{
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        // serialize base class information
        ar & boost::serialization::base_object<bus_stop>(*this);
        ar & street1;
        ar & street2;
    }
    std::string street1;
    std::string street2;
    virtual std::string description() const
    {
        return street1 + " and " + 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_)
    {}
};

注意派生类是如何调用基类的序列化函数的。千万不要直接调用基类的serialize 函数。这样做看上去似乎是可以工作,但是这样会绕过用来排除冗余数据的代码,而且会绕过版本机制。基于这个原因,建议总是将 serialize 设置为私有成员函数。语句friend boost::serialization::access 会保证serialization library 可以存取类的私有成员和调用类的私有函数。

指针

假设我们现在定义一个bus stops的数组作为bus route。 考虑到:

  1. 我们可能有几种不同的bus stops(bus_stop作为基类)
  2. 一个特定的bus_stop可能不只出现在一个线路中。

用一个bus_stop指针数组来表示一个bus route是很自然的方式。


class bus_route
{
    friend class boost::serialization::access;
    bus_stop * stops[10];
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        int i;
        for(i = 0; i < 10; ++i)
            ar & stops[i];
    }
public:
    bus_route(){}
};

stops数组的每一个元素都会被序列化。但是,记住它的每一个元素都是一个指针——这又意味着什么呢?指针指向的对象可以在下一次通过序列化重新构造时在另一个地址生存。为了完成一个指针的序列化,仅仅存储指针的值是不够的,它所指向的对象同样也必须被存储。当下一次指针成员重新被载入时,它所指向的对象必须也已经被建立好了,而只是指针就指向这个新的对象。

所有这些都由我们的库自动地完成了。以上的代码就是所有你想正确的序列化一个指针时所要做的工作。 

数组

当然上面的例子还是做得有些复杂了,我们有更简单的方法。我们的序列化库自动的检测一个对象是不是数组,如果是则生成与上面等价的代码。所以上面的代码可以简化为:


class bus_route
{
    friend class boost::serialization::access;
    bus_stop * stops[10];
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & stops;
    }
public:
    bus_route(){}
};

STL容器

上面的例子使用了成员数组。当更常见的是程序会使用一个STL容器来达到相同的目的。我们的序列化库包括了序列化STL类需要的所有代码。因此下面的代码如你所想将正常的工作。


#include <boost/serialization/list.hpp>

class bus_route
{
    friend class boost::serialization::access;
    std::list<bus_stop *> stops;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & stops;
    }
public:
    bus_route(){}
};

类的版本化

假定我们现在对bus_route已经很满意了,我们用它构造了一个程序然后发布了它。一段时间过后,发现程序需要功能的加强,而且bus_route也必须做出相应的更改是能够包括司机的名字。我们的新版本如下所示:


#include <boost/serialization/list.hpp>
#include <boost/serialization/string.hpp>

class bus_route
{
    friend class boost::serialization::access;
    std::list<bus_stop *> stops;
    std::string driver_name;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & driver_name;
        ar & stops;
    }
public:
    bus_route(){}
};

很好,我们做到了。但是……那些使用我们以前版本的程序的人怎么办呢?他们可能有大量用以前的程序构造起来的档案文件,这些如何在我们的新版本的程序中继续使用呢?

通常情况下,我们的库为每一个需要序列化的类存储了一个版本号码。默认的,这个版本号是0。当档案被加载时,序列化函数将得到档案的版本号,利用它我们可以达到向上兼容的目的:


#include <boost/serialization/list.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/version.hpp>

class bus_route
{
    friend class boost::serialization::access;
    std::list<bus_stop *> stops;
    std::string driver_name;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        // only save/load driver_name for newer archives
        if(version > 0)
            ar & driver_name;
        ar & stops;
    }
public:
    bus_route(){}
};

BOOST_CLASS_VERSION(bus_route, 1)

需要版本化的类不需要另外考虑维护档案的版本问题,档案的版本是由包含在其中的类的版本构成的集合。我们的库让新版本的程序和以前版本的程序构造的档案保持兼容性,而所要做的工作不会比上面的代码复杂多少。

serializesave/load分开实现

serialize 相当简洁明了的保证了类的成员以正确的顺序存储和载入——这是一个序列化系统的关键。然而有些情况下,载入和存储操作并不一定和上面的例子相似。例如,这在一个类进化成多版本时常常会发生:


#include <boost/serialization/list.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/split_member.hpp>

class bus_route
{
    friend class boost::serialization::access;
    std::list<bus_stop *> stops;
    std::string driver_name;
    template<class Archive>
    void save(Archive & ar, const unsigned int version) const
    {
        // note, version is always the latest when saving
        ar  & driver_name;
        ar  & stops;
    }
    template<class Archive>
    void load(Archive & ar, const unsigned int version)
    {
        if(version > 0)
            ar & driver_name;
        ar  & stops;
    }
    BOOST_SERIALIZATION_SPLIT_MEMBER()
public:
    bus_route(){}
};

BOOST_CLASS_VERSION(bus_route, 1)

BOOST_SERIALIZATION_SPLIT_MEMBER() 生成了正确调用save()和load()的代码。

档案

上面我们的讨论主要集中在了在类中增加序列化的能力。但数据的真实的描述工作是在archive类中实现的。因此序列化数据流是类和所用的档案类型一同生成的产品。将两者分开实现是一个关键性的设计。这允许特定的序列化过程用于任何的档案类型。

在这个指南中,我们只用了一个档案类型——用来存储的text_oarchive 和用来在入的 text_iarchive 。库中自带的其他的档案类型的接口都是相同的(只有一个例外)。一旦为类定义了序列化功能,类就可以使用任何一种档案进行特定的序列化过程。

如果提供的各种档案还不能满足特定程序的需求的话,你也可以构造自己的档案类型或者从已有的档案类派生。这将在后面的手册中做讨论。

注意,尽管我们的例子是在同一个程序中使用同一个档案文件,这只是为了演示的目的。但你依然可以在不同的程序使用不同程序生成的档案。

完整的演示程序—— demo.cpp 做了下列事:

  1. 建立一个有不同的车站,线路和时间表构成的数据结构。
  2. 显示它。
  3. 将它序列化到文件"testfile.txt"
  4. 在另一个结构中重新载入数据 
  5. 显示另一个数据结构的内容。 

程序的输出 已经足够证明我们的系统达到了overview中提到的10个需求。档案文件的内容 可以以一个普通的ascii文件的形式显示出来。


© Copyright Robert Ramey 2002-2004. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

0 0

相关博文

我的热门文章

img
取 消
img