最便捷、最强大、速度最快的C++序列化框架

项目地址：http://code.google.com/p/febird

最便捷、最强大、速度最快的C++序列化框架。

 

特别注意：vc6太古老，不符合C++规范，无法使用该框架

1.        高性能，速度非常快，比你能找到的同类产品至少快一个数量级

2.        在网络通讯，数据库存储中非常好用。

3.        预先支持所有基本类型，所有stl容器类型（除stack/queue之外）

4.        支持变长int32/uint32/int64/uint64

5.        支持stl::pair，boost::tuple

6.        可选的版本控制，而非强制

a)        对于小对象，通常不需要版本控制

b)        boost::serialization的版本号是强制的，当初我设计这个序列化框架就是因为boost不能省略版本号

7.        非侵入式设计，不污染名字空间

8.        声明式语法，简单，可靠

9.        …….

该框架的易用性

还是用代码说明问题 (Talk is cheap. Show me the code. Torvalds, Linus (2000-08-25) )。

看这个例子：

struct MyData1
{
    int  a, b, c;
    var_int32_t d;  // d.t is int32 value
    var_uint64_t e; // e.t is uint64 value
    std::string f;
    std::map<std::string, int> g;
    std::set<int> h;
 
    // 声明序列化，无版本控制，最简洁的声明，后面几个稍微复杂点
    DATA_IO_LOAD_SAVE(MyData1, &a&b&c&d&e&f&g&h)
};
 
struct MyData2
{
    int  a, b, c;
    var_int32_t d;
    var_uint64_t e;
    std::string f;
    std::map<std::string, int> g;
    std::set<int> h;
 
    // 声明序列化，有版本控制
    DATA_IO_LOAD_SAVE_V(MyData2,
        1, // 当前版本
        &a&b&c&d&e&f&g&h
        )
};
 
struct MyData3
{
    int  a, b, c;
    boost::int32_t d;
    boost::uint64_t e;
    std::string f;
    std::map<std::string, int> g;
    std::set<int> h;
    std::multiset<int> i;
 
    unsigned version;
 
    // 声明序列化，有版本控制
    DATA_IO_LOAD_SAVE_V(MyData3,
        2, // 当前版本
        &a
        &b
        &c
        &as_var_int(d) // d 声明为int32_t, 但是作为var_int32_t 来存储
        &as_var_int(e) // e 声明为uint64_t, 但是作为var_uint64_t 来存储
        &f
        &g
        &h
        &vmg.since(2, i) // 版本2 新增了成员i
        &vmg.get_version(version) // 如果需要，将版本值存入version 成员
        )
};
 
int main(int argc, char* argv[])
{
    PortableDataOutput<AutoGrownMemIO> output;
    PortableDataInput<MemIO> input;
 
    output.resize(1024); // 可选，没有这一行就需要扩张几次，相当于 vector.reserve
 
    MyData1 d1;
    // set d1 values
    // ...
    MyData2 d2;
    // set d2 values
    // ...
    MyData3 d3;
    // set d3 values
    // ...
    output << d1 << d2 << d3; // 存储
 
    input = output.head(); // 浅拷贝，将 input 设为 output 已写入的那部分
    input >> d1 >> d2 >> d3; // 载入
 
//----------------------------------
 
// operator& 与operator<< 等效
    output & d1 & d2 & d3; // 存储

    input = output.head(); // 浅拷贝，将 input 设为 output 已写入的那部分 
// operator& 与operator>> 等效
    input & d1 & d2 & d3; // 载入
}
 

模仿这段代码，可以完成大部分的现实需求，如果有更多的需求，可以使用该框架的高级功能。例如，系统中已经定义了一些数据结构，但又不能修改现有代码，怎样给它们增加序列化能力呢？请看如下代码：

// in system header, can not change
struct SysData1 {
    int a;
    unsigned b;
    string c;
};
// add these 2 function in your header
template<class DataIO>
void DataIO_saveObject(DataIO& dio, const SysData1& x) {
    dio & x.a & x.b & x.c;
}
template<class DataIO>
void DataIO_loadObject(DataIO& dio, SysData1& x) {
    dio & x.a & x.b & x.c;
}
// DataIO 新版中，更简单的方法  
DATA_IO_LOAD_SAVE_E(SysData2, &a &b &c)
// #######################################################################
// 如果现存的对象需要版本控制，参考如下代码：
struct SysData2 {
    int a;
    unsigned b;
    string c;
};
// add these 2 function in your header
template<class DataIO>
void DataIO_saveObject(DataIO& dio, const SysData2& x) {
    const unsigned curr_version = 2;
    dio & serialize_version_t(curr_version);
    dio & x.a & x.b;
    dio & x.c;
}
template<class DataIO>
void DataIO_loadObject(DataIO& dio, SysData2& x) {
    const unsigned curr_version = 2;
    serialize_version_t loaded_version;
    in >> loaded_version;
    if (loaded_version.t > curr_version) {
        throw BadVersionException(loaded_version.t, curr_version, className);
    }
    dio & x.a & x.b;
    if (loaded_version.t >= 2)
        dio & x.c;
}
// DataIO 新版中，更简单的方法:
DATA_IO_LOAD_SAVE_EV(SysData2, &a &b& vmg.since(2, c))

How It Works

DataIO_loadObject/DataIO_saveObject只要在调用点可见，就可以对 SysData 进行序列化。因为 DataIO 序列化框架使用DataIO_loadObject/DataIO_saveObject来载入和存储对象，这样做的好处有以下几点：

l 非侵入，对象类型和加载/存储函数可以分离定义

n  否则无法为不可更改代码的对象增加序列化能力

l 这两个函数可以定义在任何名字空间

n  根据C++的名字查找规则，只要在调用环境和每个参数所在的名字空间中有相应的匹配函数，就会使用该函数。我们需要有效地利用这一点。

l DataIO_loadObject/DataIO_saveObject这两个函数名较长，并且罕见

n  因此不会与系统中的其他标识符发生冲突。（对比boost::serialization中的serialize函数，它就比较容易和其他名字发生冲突，serialize太常见了）。

 

性能

在上面的代码中可以看到几个陌生的名字：MemIO, AutoGrownMemIO,PortableDataOutput, PortableDataInput…

 但上面的示例代码中没有用到MinMemIO，因为 MinMemIO 没有越界检查，只有在非常简单，完全可控的情况下，才能使用它。因为没有越界检查，它的性能非常好，在大多数情况下相当于手写的 memcpy 序列化。

使用 MemIO 会稍微慢一点，但是有越界检查，读取时越界会抛出 EndOfFileException 异常，写入越界时会抛出 OutOfSpaceException 异常。

使用AutoGrownMemIO，在save时，碰到边界会自动增加内存（相当于vector.push_back自动增加内存），也可以使用resize预先分配内存（相当于vector.reserve/resize）。

这个几个MemIO类都非常简单，速度快是很自然的。

在PortableDataOutput，PortableDataInput中，如果机器字节序是LittleEndian，需要交换字节序，这一点，在新版的vc中和gcc中，会直接映射到一条指令：bswap。所以也不会有性能问题。

对于var_int的存储，无符号数，每个字节包含7个有效位，余下一位表示是否需要读取下一个字节。因此0~127仅需要一个字节，0~2^14-1需要两个字节，等等。对于有符号数，最低有效位存储符号，其余位存储绝对值。所有stl容器和string的尺寸就是用var_uint32_t存储的。

该框架中，同时实现了StreamBuffer，可以为任意Stream增加一层缓冲，往缓冲里面序列化数据的效率和MemIO系列是一样的，不同之处在于当缓冲耗尽或填满时会调用真实Stream的读写方法。这比起通常很多实现中将BufferedStream作为一个抽象，在读取哪怕一个字节时也需要一个虚函数调用，速度要快得多。

扩展应用

使用该序列化框架，我实现了一个不需要 IDL的 RPC 。

使用该序列化框架，对 Berkeley DB 进行包装，可以让它象标准容器一样使用，免除了复杂的编码。后面我会继续介绍。

项目地址：http://code.google.com/p/febird