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

来源：互联网发布：软件培训班学费编辑：程序博客网时间：2024/04/27 23:13

作者：天狼（http://my.csdn.net/whinah）

项目地址：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) )。

看这个例子：

[cpp] view plaincopy

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; // 载入
}

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

[cpp] view plaincopy

// 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