boost序列化多态类指针的例子

[cpp] view
plaincopy

#define BOOST_ALL_NO_LIB

#include <iostream>

#include <fstream>

#include <boost/archive/text_iarchive.hpp>

#include <boost/archive/text_oarchive.hpp>

#include <boost/serialization/export.hpp>

class A

{

public:

int a;

A() : a(0) {}

virtual void foo() = 0;

friend class boost::serialization::access;

template<class Archive>

void serialize(Archive & ar, const unsigned int version)

{

ar & a;

}

};

BOOST_SERIALIZATION_ASSUME_ABSTRACT(A)

class A_1 : public A

{

public:

int a1;

A_1() { a=1; a1=11;}

virtual void foo() { std::cout << "A_1:" << a << ", " << a1 << std::endl; }

template<class Archive>

void serialize(Archive & ar, const unsigned int version)

{

ar & boost::serialization::base_object<A>(*this);

ar & a1;

}

};

BOOST_CLASS_EXPORT(A_1)

class A_2 : public A

{

public:

int a2;

A_2() { a=2; a2=22;}

virtual void foo() { std::cout << "A_2:" << a << ", " << a2 << std::endl; }

template<class Archive>

void serialize(Archive & ar, const unsigned int version)

{

ar & boost::serialization::base_object<A>(*this);

ar & a2;

}

};

BOOST_CLASS_EXPORT(A_2)

int main(int argc, char ** argv)

{

A * pa = new A_2();

std::ofstream ofs("aaa.txt");

boost::archive::text_oarchive oa(ofs);

oa << pa;

ofs.close();

A * pa2;

std::ifstream ifs("aaa.txt");

boost::archive::text_iarchive ia(ifs);

ia >> pa2;

ifs.close();

return 0;

}

测试过，挺好用的。

其他的序列化方式：

Learning boost Serialization
简单的开始
Serialization的中文解释是“串行化” 、“序列化”或者“持久化” ，就是将内存中的对象保存到磁盘中，等到程序再次运行的时候再读取磁盘中的文件恢复原来的对象。下面来看一个简单的例子：

#include <fstream>

#include <iostream>

#include <boost/archive/text_oarchive.hpp>

#include <boost/archive/text_iarchive.hpp>

class A

{

private:

//为了能让串行化类库能够访问私有成员，所以要声明一个友元类

friend class boost::serialization::access;

//对象的数据

int a;

double b;

//串行化的函数，这一个函数完成对象的保存与恢复

template<class Archive>

void serialize(Archive & ar, const unsigned int version)

{

ar & a; //就是这么简单，也可以使用 ar<<a 这样的语法

ar & b;

}

public:

A(int aa,double bb):a(aa),b(bb){}

A(){}

void print(){std::cout<<a<<' '<<b<<std::endl;}

};

int main()

{

std::ofstream fout("file.txt");//把对象写到file.txt文件中

boost::archive::text_oarchive oa(fout);//文本的输出归档类，使用一个ostream来构造

A obj(1,2.5);

oa<<obj;//保存obj对象

fout.close();//关闭文件

std::ifstream fin("file.txt");

boost::archive::text_iarchive ia(fin);//文本的输入归档类

A newobj;

ia>>newobj;//恢复到newobj对象

newobj.print();

fin.close();

system("pause");

return 0;

}

从上面可以看出，boost是使用text_oarchive和text_iarchive 类，来完成一个对象的序列化的。使用这两个类的步骤是：
1. 在源程序中包含boost/archive/text_oarchive.hpp 和 boost/archive/text_iarchive.hpp 这两个文件。
2. 为需要序列化的类添加一个template<class Archive> void serialize(Archive & ar, const unsigned int version)的模版成员函数。
3. 如果需要对象中包含私有成员的话，需要把boost::serialization::access类声明为友元。
4. 在主函数中，创建一个输出文件流对象， 使用这个对象构造一个text_oarchive对象，然后就可以使用<<操作符来输出对象了。
5. 最后，同样的，使用text_iarchive来恢复对象。

继承
如果要序列化一个子类的话，方法是不同的。例：

#include <boost/serialization/base_object.hpp> //一定要包含此头文件

class B:A

{

friend class boost::serialization::access;

char c;

template<class Archive>

void serialize(Archive & ar, const unsigned int version)

{

ar & boost::serialization::base_object<A>(*this);//注意这里

ar & c;

}

public:

...

};

对子类进行序列化的步骤是：
1. 包含boost/serialization/base_object.hpp头文件
2. 在serialize模版函数中，使用ar & boost::serialization::base_object<父类>(*this)这样的语法来保存父类的数据，不能直接调用父类的serialize函数

STL容器
如果要序列化一个STL容器，要使用boost自带的头文件，不能直接#include<vector>
例如：

#include <boost/serialization/list.hpp>// Serialization中特定的头文件,在list.hpp中已经包含了stl的list头文件

Class A

{

...

list<int> list;

template<class Archive>

void serialize(Archive & ar, const unsigned int version)

{

ar & list;

}

...

}

在Serialization中，类似的头文件还有vector.hpp string.hpp set.hpp map.hpp slist.hpp等等。

数组和指针
对于数组和指针可以直接序列化，例：

Class A

{

...

int a[10];

int *b

template<class Archive>

void serialize(Archive & ar, const unsigned int version)

{

ar & a;

ar & b;

}

...

}

其他的archive类
除了text_iarchive和text_oarchive之外，还有其他的archive类，可以把对象保存成不同格式的文件。

// a portable text archive

boost::archive::text_oarchive(ostream &s) // saving

boost::archive::text_iarchive(istream &s) // loading

// a portable text archive using a wide character stream

boost::archive::text_woarchive(wostream &s) // saving

boost::archive::text_wiarchive(wistream &s) // loading

// a non-portable native binary archive

boost::archive::binary_oarchive(ostream &s) // saving

boost::archive::binary_iarchive(istream &s) // loading

// a portable XML archive

boost::archive::xml_oarchive(ostream &s) // saving

boost::archive::xml_iarchive(istream &s) // loading

// a portable XML archive which uses wide characters - use for utf-8 output

boost::archive::xml_woarchive(wostream &s) // saving

boost::archive::xml_wiarchive(wistream &s) // loading