Boost::Serialization试用手记

Boost::Serialization试用手记

http://www.360doc.com/content/12/0730/17/832545_227310360.shtml

对于核心数据相对比较集中的应用程序来说，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 )