对于核心数据相对比较集中的应用程序来说,serialization机制可以直接充当文档保存与打开功能的实现工具,这也是很多成熟的应用程序framework都提供serialization支持的原因
但是个人认为,serialization最精彩的用处在于保存现场,比如在探索性的科研应用程序开发过程中,很可能一部分算法已经固定下来,其余的有待进一步探索,而确定下来的部分有可能十分time consuming,如果每次改一下算法都要从头计算,就会很费时间,长期下去对工作情绪会有很大影响,这时候可以用serialization把每一步的结果存成文件,下次启动时任选一个开始新的计算。
Boost的Serialization库是一个十分强大的工具,它文档中提到的11个开发目标列举如下:
1.代码移植性,只依赖于ANSI C++标准
2.代码简洁性,的确运用Boost::Serialization所需要的代码量很小
3.每个类有自己独立的版本控制,以保证旧的save结果可以被新的程序load回来
4.深度指针save与load,不仅serialize指针本身,而且包括它指向的对象数据
5.多个指针指向同一个对象不会被serialize多次
6.对常用STL容器的支持
7.串行数据的平台移植性
8.类如何被串行化与串行数据按何种格式存储相互无关
9.非侵入性,这对于数据中使用了第三方类库的情形很有效
最后两个没有理解,希望高人指点
10.The archive interface must be simple enough to easily permit creation of a new type of archive.
11.The archive interface must be rich enough to permit the creation of an archive that presents serialized data as XML in a useful manner.
下面是我试用Boost::Serialization的记录
第一个例子
假设有这样一个类需要串行化
class
Data
{
public
:
int
mInt;
}
;
这里为了简化起见,成员变量都设成public了,串行化的代码如下
1
#include
<
fstream
>
2
3
//
fewest include headers
4
#include
<
boost
/
archive
/
text_iarchive.hpp
>
5
#include
<
boost
/
archive
/
text_oarchive.hpp
>
6
7
//
use this to ease the archive selection
8
typedef boost::archive::text_iarchive iarchive;
9
typedef boost::archive::text_oarchive oarchive;
10
11
class
Data
12
{
13
friend
class
boost::serialization::access;
14
15
protected
:
16
17
template
<
class
Archive
>
18
void
serialize(Archive
&
ar,
const
unsigned
int
/**/
/*
file_version
*/
)
19
{
20
ar
&
mInt;
21
}
22
23
public
:
24
25
int
mInt;
26
27
static
void
saveData(
const
Data
&
obj, std::
string
fileName)
28
{
29
std::ofstream ofs(fileName.c_str());
30
oarchive oa(ofs);
31
oa
<<
obj;
32
}
33
34
static
void
loadData(Data
&
obj, std::
string
fileName)
35
{
36
std::ifstream ifs(fileName.c_str());
37
iarchive ia(ifs);
38
ia
>>
obj;
39
}
40
}
;
41
42
void
main()
43
{
44
Data d1;
45
d1.mInt
=
3
;
46
47
Data::saveData(d1,
"
output.txt
"
);
48
49
Data d2;
50
Data::loadData(d2,
"
output.txt
"
);
51
52
//
results should be the same.
53
ToolLib::LOG(TOSTR(d2.mInt));
54
}
成员serialize函数是定义类如何被串行化之规则的核心。
由于使用了RTTI机制,serialize函数不需要为virtual,永远只要是void就可以,在串行化指针的时候能够被正确调用。
serialize函数中的 & 运算符在load时调用 >>,而在save时调用 <<,这样save和load只要一个函数就可以。
saveData和loadData函数必不可少,由于serialization库强大的编译检查机制,如果不用这样的方式来save一个对象,往往会因为这个对象不是const而编译失败。
所用的archive类型可以任选,如text或binary,上例中的typedef即是为了封装这一变化
非侵入性
下面一例演示了串行化不可侵入的类型。这里用的是 WildMagicLib2.5中的 2-Vector
#include
<
WildMagic2p5
/
Include
/
WmlVector2.h
>
class
Data
{
friend
class
boost::serialization::access;
protected
:
template
<
class
Archive
>
void
serialize(Archive
&
ar,
const
unsigned
int
/**/
/*
file_version
*/
)
{
ar
&
mVec2d;
}
public
:
Wml::Vector2d mVec2d;
static
void
saveData(
const
Data
&
obj, std::
string
fileName);
static
void
loadData(Data
&
obj, std::
string
fileName);
}
;
namespace
boost
{
namespace
serialization
{
template
<
class
Archive,
class
Real
>
void
serialize(Archive
&
ar, Wml::Vector2
<
Real
>&
g,
const
unsigned
int
version)
{
ar
&
g.X();
ar
&
g.Y();
}
}
//
namespace serialization
}
//
namespace boost
这种情况下,需要这个全局serialize在能够访问到那个类里需要串行化的数据,常常load和save的方法不一样,如load时调用setVar,save时调用getVar,这时Archive::is_loading和Archive::is_saving常数就有用了。一种等价但是更直观的方法是使用BOOST_SERIALIZATION_SPLIT_MEMBER或者BOOST_SERIALIZATION_SPLIT_FREE宏,两者分别生成调用load/save成员函数和load/save全局函数的代码。
在serialization内部,是通过定义全局serialize函数模板,并在里面调用成员serialize函数来实现的,如下所示,需要非侵入的对象只要特化这个全局函数就可以了。
//
default implemenation - call the member function "serialize"
template
<
class
Archive,
class
T
>
inline
void
serialize(
Archive
&
ar, T
&
t,
const
BOOST_PFTO unsigned
int
file_version
)
{
access::serialize(ar, t, static_cast
<
unsigned
int
>
(file_version));
}
STL容器支持
通过包含一些serialization提供的头文件,对STL容器可以像普通变量一样支持
//
STL support headers
#include
<
boost
/
serialization
/
vector.hpp
>
#include
<
boost
/
serialization
/
string
.hpp
>
class
Data
{
friend
class
boost::serialization::access;
protected
:
template
<
class
Archive
>
void
serialize(Archive
&
ar,
const
unsigned
int
/**/
/*
file_version
*/
)
{
ar
&
mStr;
ar
&
mVecInt;
ar
&
mVecStr;
}
public
:
std::
string
mStr;
std::vector
<
int
>
mVecInt;
std::vector
<
std::
string
>
mVecStr;
static
void
saveData(
const
Data
&
obj, std::
string
fileName);
static
void
loadData(Data
&
obj, std::
string
fileName);
}
;
指针与数组
class
ClassA
{
public
:
int
mInt;
}
;
class
Data
{
friend
class
boost::serialization::access;
protected
:
template
<
class
Archive
>
void
serialize(Archive
&
ar,
const
unsigned
int
/**/
/*
file_version
*/
)
{
ar
&
mPtrInt;
ar
&
mArrInt;
ar
&
mPtrData;
ar
&
mPtrA;
}
public
:
Data():mPtrData(NULL), mPtrInt(NULL), mPtrA(NULL)
{}
Data
*
mPtrData;
int
mArrInt[
10
];
int
*
mPtrInt;
ClassA
*
mPtrA;
static
void
saveData(
const
Data
&
obj, std::
string
fileName);
static
void
loadData(Data
&
obj, std::
string
fileName);
}
;
namespace
boost
{
namespace
serialization
{
template
<
class
Archive
>
void
serialize(Archive
&
ar,
int
&
g,
const
unsigned
int
version)
{
ar
&
g;
}
}
//
namespace serialization
}
//
namespace boost
数组可以直接串行化,指针比须保证有效,所以必须保证在串行化之前经过初始化。
对于基本类型如int,可以直接串行化,但其指针int*,要当作不可侵入类型的指针来看待,所以需要一个全局serialize函数来说明int类型的串行化方式
对于有基类指针的串行化,代码如下
class
ClassA
{
public
:
int
mIntA;
virtual
void
someMethod()
=
NULL;
template
<
class
Archive
>
void
serialize(Archive
&
ar,
const
unsigned
int
/**/
/*
file_version
*/
)
{
ar
&
mIntB;
}
}
;
BOOST_IS_ABSTRACT(ClassA)
class
ClassB:
public
ClassA
{
public
:
int
mIntB;
virtual
void
someMethod()
{}
template
<
class
Archive
>
void
serialize(Archive
&
ar,
const
unsigned
int
/**/
/*
file_version
*/
)
{
ar
&
boost::serialization::base_object
<
ClassA
>
(
*
this
);
ar
&
mIntB;
}
}
;
BOOST_CLASS_EXPORT(ClassB)
纯虚类后加上BOOST_ISABSTRACT,而可能会被串行化到的子类用BOOST_CLASS_EXPORT,这样就可以在任何地方串行化 ClassA* 的成员变量。
子类的serialize函数里必须要照顾到基类的成员。
版本控制
在serialize函数中的version参数就是用于版本控制的,所有类的版本号默认为0,新版本的类可以自己指定版本号以便与旧版本相区别。如下
BOOST_CLASS_VERSION(ClassA, 1)
对于save过程,版本号始终为新的,而load过程取决于文件中保存的值,对于新版本新增变量的情况可以这样解决
//
old definition
class
ClassA
{
public
:
int
mInt;
}
;
//
new definition
class
ClassA
{
public
:
int
mInt;
int
mIntNew;
template
<
class
Archive
>
void
serialize(Archive
&
ar,
const
unsigned
int
ver)
{
ar
&
mInt;
if
(ver
==
1
)
ar
&
mIntB;
}
}
;
BOOST_CLASS_VERSION(ClassA,
1
)
对于有改动的情形,稍微复杂一点,可以这样
//
old definition
class
ClassA
{
public
:
TypeA mVarA;
}
;
//
new definition
class
ClassA
{
public
:
//
suppose now we use B and C instead of A
TypeB mVarB;
TypeC mVarC;
template
<
class
Archive
>
void
serialize(Archive
&
ar,
const
unsigned
int
ver)
{
if
(ver
<
1
)
{
//
here must be loading
TypeA varA;
ar
&
varA;
//
now derive mVarB & mVarC from varA;
}
else
{
ar
&
mVarB;
ar
&
mVarC;
}
}
}
;
BOOST_CLASS_VERSION(ClassA,
1
)