对象序列化实验.docx

对象序列化实验.docx

《对象序列化实验.docx》由会员分享，可在线阅读，更多相关《对象序列化实验.docx（37页珍藏版）》请在冰豆网上搜索。

对象序列化实验

电子科技大学

实验报告

学生姓名：

学号：

指导教师：

实验地点：

实验时间：

2011.12.14

一、实验室名称：

Linux环境高级编程实验室

二、实验项目名称：

对象序列化实验

三、实验学时：

8学时

四、实验目的：

熟悉基本的对象序列化方法

5、实验内容：

共进行5个版本的开发：

●版本1：

将一个类的一个对象序列化到文件

●版本2：

将一个类的多个对象序列化到文件

●版本3：

将两个类的多个对象序列化到文件

●版本4：

按照面向对象的方法，解决多个类的多个对象序列化到文件的问题

●版本5：

序列化的目的地不仅可以是文件，还可以是其他，即可配置性

六、实验步骤：

实验一：

Test_1.cpp:

#include

#include

#include

usingnamespacestd;//指定名字空间

classtest_1

{

private:

intx;

public:

test_1（）

{

intx=0;

}

explicittest_1（inty）

{

x=y;

}

virtual~test_1（）//虚函数

{

}

public:

voidfile（）

{

cout<<"infile（）:

"<

}

public:

boolSerialize（constchar*path）const//序列化部分

{

intfd=open（path,O_RDWR|O_CREAT|O_TRUNC,0）;//打开experiment文件

if（-1==fd）

returnfalse;

if（write（fd,&x,sizeof（int））==-1）//写文件

{

close（fd）;

returnfalse;

}

if（:

:

close（fd）==-1）//关闭文件

returnfalse;

returntrue;

}

boolDeserialize（constchar*path）//反序列化部分

{

intfd=open（path,O_RDWR）;//

if（-1==fd）

returnfalse;

intred=read（fd,&x,sizeof（int））;//只序列化一个值

if（-1==red）

{

close（fd）;

returnfalse;

}

if（close（fd）==-1）

returnfalse;

returntrue;

}

};

intmain（）

{

{

test_1ex（1314）;

ex.Serialize（"recored.txt"）;

}

{

test_1ex;

ex.Deserialize（"recored.txt"）;

ex.file（）;

}

return0;

}

运行结果：

如图1所示

图1：

test_1运行结果

实验二：

Test_2.cpp:

#include

#include

#include

usingnamespacestd;

classtest_2

{

private:

intx;

public:

test_2（）

{

intx=0;

}

explicittest_2（inty）

{

x=y;

}

virtual~test_2（）

{

}

public:

voidfile（）

{

cout<<"infile（）:

"<

}

public:

boolSerialize（constchar*Path）const

{

intfd=open（Path,O_RDWR|O_CREAT|O_TRUNC,0）;//打开文件

if（-1==fd）

returnfalse;

if（Serialize（fd）==false）//函数重载

{

close（fd）;

returnfalse;

}

if（close（fd）==-1）

returnfalse;

returntrue;

}

boolDeserialize（constchar*Path）

{

intfd=open（Path,O_RDWR）;

if（-1==fd）

returnfalse;

if（Deserialize（fd）==false）

{

close（fd）;

returnfalse;

}

if（close（fd）==-1）

returnfalse;

returntrue;

}

boolSerialize（intfd）const

{

if（-1==fd）

returnfalse;

if（write（fd,&x,sizeof（int））==-1）//x值写入文件

returnfalse;

returntrue;

}

boolDeserialize（intfd）

{

if（-1==fd）

returnfalse;

intrd=read（fd,&x,sizeof（int））;//读出文件中的x值

if（（0==rd）||（-1==rd））

returnfalse;

returntrue;

}

};

classSerializerFortest_2

{

public:

SerializerFortest_2（）

{

}

virtual~SerializerFortest_2（）

{

}

public:

boolSerialize（constchar*Path,constvector&vec）

{

intfd=open（Path,O_RDWR|O_CREAT|O_APPEND,0）;//打开文件

if（-1==fd）

returnfalse;

for（intx=0;x

{

vec[x].Serialize（fd）;

}

close（fd）;

returntrue;

}

boolDeserialize（constchar*Path,vector&vec）

{

intfd=open（Path,O_RDWR）;

if（-1==fd）

returnfalse;

for（;;）

{

test_2ex;

if（ex.Deserialize（fd）==true）//读出数组

{

vec.push_back（ex）;

}

else

break;

}

close（fd）;

returntrue;

}

};

intmain（）

{

{

test_2ex1（6）,ex2（7）,ex3（9）;//序列化数组

vectorvec;

vec.push_back（ex1）;

vec.push_back（ex2）;

vec.push_back（ex3）;

SerializerFortest_2ser;

ser.Serialize（"record.txt",vec）;

}

{

SerializerFortest_2ser;//反序列化

vectorvec;

ser.Deserialize（"record.txt",vec）;

for（intx=0;x<3;x++）

{

vec[x].file（）;

}

}

return0;

}

运行结果如图2所示：

图2：

test_2运行结果

实验三：

Test_3.cpp:

#include

#include

#include

usingnamespacestd;

classtest_A

{

private:

intx;

public:

test_A（）

{

intx=0;

}

explicittest_A（inty）

{

x=y;

}

virtual~test_A（）

{

}

public:

voidfile（）

{

cout<<"infile（）:

"<

}

public:

boolSerialize（intfd）

{

if（-1==fd）

returnfalse;

if（:

:

write（fd,&x,sizeof（int））==-1）

returnfalse;

returntrue;

}

boolDeserialize（intfd）

{

if（-1==fd）

returnfalse;

intrd=read（fd,&x,sizeof（int））;

if（（0==rd）||（-1==rd））

returnfalse;

returntrue;

}

};

classtest_B

{

private:

intx;

inty;

public:

test_B（）

{

x=0;

y=0;

}

explicittest_B（intk）

{

x=k;

y=k+1;

}

virtual~test_B（）

{

}

public:

voidfile（）

{

cout<<"infile（）:

"<

}

public:

boolSerialize（intfd）

{

if（-1==fd）

returnfalse;

if（write（fd,&x,sizeof（int））==-1）

returnfalse;

if（write（fd,&y,sizeof（int））==-1）

returnfalse;

returntrue;

}

boolDeserialize（intfd）

{

if（-1==fd）

returnfalse;

intrd=read（fd,&x,sizeof（int））;

if（（0==rd）||（-1==rd））

returnfalse;

rd=read（fd,&y,sizeof（int））;

if（（0==rd）||（-1==rd））

returnfalse;

returntrue;

}

};

structSerialized

{

intnType;//0fortest_A;1fortest_B

void*pObj;

};

classSerializer

{

public:

boolSerialize（constchar*Path,std:

:

vector&vec）

{

intfd=open（Path,O_RDWR|O_CREAT|O_TRUNC,0）;

if（-1==fd）

returnfalse;

for（intx=0;x

{

if（write（fd,&（vec[x].nType）,4）==-1）

{

close（fd）;

returnfalse;

}

if（0==vec[x].nType）

{

test_A*p=（test_A*）（vec[x].pObj）;

if（p->Serialize（fd）==false）

returnfalse;

}

elseif（1==vec[x].nType）

{

test_B*p=（test_B*）（vec[x].pObj）;

if（p->Serialize（fd）==false）

returnfalse;

}

}

if（close（fd）==-1）

returnfalse;

returntrue;

}

boolDeserialize（constchar*Path,std:

:

vector&vec）

{

intfd=open（Path,O_RDWR）;

if（-1==fd）

returnfalse;

for（;;）

{

intnType;

intrd=read（fd,&nType,4）;

if（（-1==rd）||（0==rd））

break;

if（0==nType）

{

test_A*p;

p=newtest_A（）;

p->Deserialize（fd）;

Serializeds;

s.nType=nType;

s.pObj=p;

vec.push_back（s）;

}

elseif（1==nType）

{

test_B*p;

p=newtest_B（）;

p->Deserialize（fd）;

Serializeds;

s.nType=nType;

s.pObj=p;

vec.push_back（s）;

}

}

if（close（fd）==-1）

returnfalse;

returntrue;

}

};

intmain（）

{

{

test_Aex1

（2）;

Serializeds1;

s1.nType=0;

s1.pObj=&ex1;

test_Bb1（3）;

Serializeds2;

s2.nType=1;

s2.pObj=&b1;

test_Bb2（4）;

Serializeds3;

s3.nType=1;

s3.pObj=&b2;

test_Aex2（5）;

Serializeds4;

s4.nType=0;

s4.pObj=&ex2;

std:

:

vectorvec;

vec.push_back（s1）;

vec.push_back（s2）;

vec.push_back（s3）;

vec.push_back（s4）;

Serializers;

s.Serialize（"data",vec）;

}

{

Serializers;

std:

:

vectorvec;

s.Deserialize（"data",vec）;

for（intx=0;x

{

if（vec[x].nType==0）

{

test_A*p=（test_A*）（vec[x].pObj）;

p->file（）;

}

elseif（vec[x].nType==1）

{

test_B*p=（test_B*）（vec[x].pObj）;

p->file（）;

}

}

}

return0;

}

运行结果如图3所示：

图3：

test_3运行结果

实验四：

Test_4.cpp:

#include

#include

#include

usingnamespacestd;

classtestSerializable//序列化虚类

{

public:

virtualboolSerialize（intfd）=0;

virtualtestSerializable*Deserialize（intfd）=0;

virtualboolGetType（int&type）=0;

public:

testSerializable（）

{

}

virtual~testSerializable（）

{

}

};

classtest_1:

publictestSerializable

{

private:

inti;

public:

test_1（）

{

i=0;

}

explicittest_1（intj）

{

i=j;

}

virtual~test_1（）

{

}

public:

voidfile（）

{

std:

:

cout<<"infile（）:

"<

:

endl;

}

public:

virtualboolGetType（int&type）

{

type=0;

returntrue;

}

virtualboolSerialize（intfd）

{

if（-1==fd）

returnfalse;

if（:

:

write（fd,&i,sizeof（int））==-1）//序列化

returnfalse;

returntrue;

}

virtualtestSerializable*Deserialize（intfd）//反序列化

{

if（-1==fd）

returnNULL;

test_1*p=newtest_1（）;

intr=:

:

read（fd,&（p->i）,sizeof（int））;

if（（0==r）||（-1==r））

{

deletep;

returnNULL;

}

returnp;

}

};

classtest_2:

publictestSerializable

{

private:

inti;

intj;

public:

test_2（）

{

i=0;

j=0;

}

explicittest_2（intk）

{

i=k;

j=k+1;

}

virtual~test_2（）

{

}

public:

voidfile（）

{

std:

:

cout<<"infile（）:

"<

:

endl;

}

public:

virtualboolGetType（int&type）

{

type=1;

returntrue;

}

virtualboolSerialize（intfd）//写入多个对象

{

if（-1==fd）

returnfalse;

if（:

:

write（fd,&i,sizeof（int））==-1）

returnfalse;

if（:

:

write（fd,&j,sizeof（int））==-1）

returnfalse;

returntrue;

}

virtualtestSerializable*Deserialize（intfd）

{

if（-1==fd）

returnNULL;

test_2*p=newtest_2（）;

intr=:

:

read（fd,&（p->i）,sizeof（int））;

if（（0==r）||（-1==r））

{

deletep;

returnNULL;

}

r=:

:

read（fd,&（p->j）,sizeof（int））;

if（（0==r）||（-1==r））

{

deletep;

returnNULL;

}

returnp;

}

};

classCLSerializer

{

private:

std:

:

vectorm_vSerialized;

public:

boolSerialize（constchar*pFilePath,std:

:

vector&v）

{

intfd=:

:

open（pFilePath,O_RDWR|O_CREAT|O_TRUNC,0）;

if（-1==fd）

returnfalse;

for（inti=0;i

{

inttype;

v[i]->GetType（type）;

if（:

:

write（fd,&type,4）==-1）

{

:

:

close（fd）;

returnfalse;

}

v[i]->Serialize（fd）;

}

if（:

:

close（fd）==-1）

returnfalse;

r