vc序列化问题

vc序列化问题(serialize)_xuesheng雪圣_

文档与序列化 一、文档的基本特征

文档类文件是从cdocument继承而来的。

the user to save a modified file before closing it.

翻译：当一个文档数据发生改变，每一个它的视图将随即发生改变。文档类在必要的时候被重绘。框架也在关闭前迅速保存改动文件。

to implement documents in a typical application, you must do the fo

of document. l add member variables to store each documen

modifying the document's data. the document's views are the most

that the user typically opens with the file open command and saves with the file save command. 翻译：文档类提供用户自定义文档类的基本功能。一个文档的打开命令和保存命令是数据单元特征。

l 为每一种类型的文档从 cdocument 派生一个类

using the interface defined by cdocument.

l 增加成员函数来存储每一个文档的数据

the cdocument class provides the basic functionality for user-defined document classes. a document represents the the cobject::serialize member function in your document class to

翻译：在一个典型类型的应用程序中实现一个文档，你必须按以下步骤：

cdocument supports standard operations such as creating a document, loading it, and saving it. the framework manipulat

翻译：文档类支持标准操作有：创建文档，载入文档，和保存。框架界面使用由文档类定义的界面。l 为读写文档数据实现成员函数。文档视图类是这个成员函数最

an application can support more than one type of document; for example, an application might support both spreadshel 在你的文档类重载 cobject::serialize 成员函数，来将文档

documents. each type of document has an associated document template; the document template specifies what resources object.

序列化： menu, icon, or accelerator table) are used for that type of document. each document contains a pointer to its associated

本文解释 microsoft 基础类库 (mfc) 中提供的序列化机制，该机制使对

翻译：一个应用程序可以支持多于一种类型的文档；例如，一个应用程序可能同时支持电子表格和普通文本文档。每一种类型的文

序列化是指将对象写入永久性存储媒体（如磁盘文件）或从其中读取对象的文档模板；文档模板指定了（例如，菜单，图标，或者加速表格）使用这些类型的文档。每个文档包含一个指针指向关联的模板对

cobject 派生的类都可利用 cobject 的序列化协议。

users interact with a document through the cview object(s) associated with it. a view renders an image of the docume序列化的基本思想是对象应能将其当前状态（通常由该对象的成员变量指示window and interprets user input as operations on the document. a document can have multiple views associated with

对象状态，可以重新创建该对象。序列化处理序列化对象时使用的对象指针user opens a window on a document, the framework creates a view and attaches it to the document. the document templa自身状态。因此，对于可序列化的类，必须实现基本的序列化操作。正如what type of view and frame window are used to display each type of document.

mfc 将 carchive 类的对象用作将被序列化的对象和存储媒体之间的中介翻译：用户将一个文档和一个视类对象想关联起来。一个视类扮演一个嵌入在文档框架内的图像，在文档内解释用户的输入操作。需的信息，包括文件名和请求的操作是读取还是写入。执行序列化操作的有多个视类与其关联。当用户在一个文档上打开一个窗体，框架创造一个视图，把它放在文档上。文档模板指定适合于用户文档类视图和框架窗口用来显示用户打开的文件。

carchive 对象使用重载输出运算符 (<<) 和输入运算符 (>>) 来执行读写

过存档存储和加载 cobjects 。 documents are part of the framework's standard command routing and consequently receive commands from standard us

components (such as the file save menu item). a document receives commands forwarded by the active view. if the docu注意 请不要将 carchive 类与通用 iostream 类混淆， iostream 类

handle a given command, it forwards the command to the document template that manages it.

象。

翻译：文档是一个框架标准命令路由，因此从标准用户界面组件（如文件保存菜单项）接受命令。一个文档由其活动视图迅速接受

如果愿意，可以不使用 mfc 序列化而为永久性数据存储创建自己的机制。

文档没有没有响应给出的命令，那么该命令将交由文档模板来管理。

id_file_open 、 id_file_save 及 id_file_save_as 标准命令的 技术说

when a document's data is modified, each of its views must reflect those modifications. cdocument provides the updateal

下列文章介绍了序列化所需的两个主要任务：

function for you to notify the views of such changes, so the views can repaint themselves as necessary. the framework

l 序列化：创建可序列化的类 l 序列化：序列化对象

{

// ...member functions

序列化：序列化与数据库输入 /输出的对比 一文描述了序列化在数据库应用程序中何时是适当的输入 public: / 输出技术。 通过存档存储和加载 cobjects

cotherobject() { }

通过存档存储及加载 cobject 需要额外注意。在某些情况下，应调用对象的 serialize 函数，其中， carchive 对象是 serialcruntimeclass 信息构造内存中的 cobject 。

// implementation

virtual void serialize( carchive& ar ) { } 数，与使用 carchive 的 “<<” 或 “>>” 运算符不同。要牢记的重要事实是： carchive 的 “>>” 运算符基于由存档先前写

因此，是使用 carchive 的 “<<” 和 “>>” 运算符还是调用 serialize ，取决于是否需要加载存档基于先前存储的 cruntime

protected: 态地重新构造对象。在下列情况下使用 serialize 函数： declare_serial( cotherobject ) l 反序列化对象时，预先知道对象的确切的类。 l 反序列化对象时，已为其分配了内存。

};

class ccompoundobject : public cobject 警告 如果使用 serialize 函数加载对象，也必须使用 serialize 函数存储对象。不要使用 carchive 的 “<<” 运算符先用 serialize 函数进行加载；或使用 serialize 函数存储，然后使用 carchive 的 “>>” 运算符进行加载。 { 以下示例阐释了这些情况：

// ...member functions

class cmyobject : public cobject

public:

{

ccompoundobject();

// ...member functions

virtual void serialize( carchive& ar );

public:

cmyobject() { }

// implementation

virtual void serialize( carchive& ar ) { }

protected:

// implementation

cmyobject m_myob; // embedded object

protected:

declare_serial( cmyobject )

cobject* m_pobdyn; // dynamically allocated object

};

//..other member data and implementation

class cotherobject : public cobject

declare_serial( ccompoundobject )

cotherobject* m_pother; // object allocated in constructor

};

implement_serial(cmyobject,cobject,1) implement_serial(cotherobject,cobject,1) implement_serial(ccompoundobject,cobject,1)

ccompoundobject::ccompoundobject() {

} else {

ar >> m_pobdyn; // polymorphic reconstruction of persisten // object

//load other members }

m_pother = new cotherobject; // exact type known and object already } //allocated.

总之，如果可序列化的类将嵌入的 cobject 定义为成员，则不应使用该对象

数。同时，如果可序列化的类将指向 cobject （或从 cobject 派生的对

m_pobdyn = null; // will be allocated in another member function 则也应调用 serialize 。 // if needed, could be a derived class object. 序列化：创建可序列化的类 }

ms-help://ms.vscc.2003/ms.msdnqtr.2003feb.2052/vccore/html/_core

使类可序列化需要五个主要步骤。下面列出了这些步骤并在以后章节内进 void ccompoundobject::serialize( carchive& ar )

从 cobject 派生类 （或从 cobject 派生的某个类中派生）。

{

重写 serialize 成员函数 。

使用 declare_serial 宏 （在类声明中）。

cobject::serialize( ar ); // always call base class serialize.

定义不带参数的构造函数 。

为类 在实现文件中使用 implement_serial 宏 。

m_myob.serialize( ar ); // call serialize on embedded member.

如果直接调用 serialize而不是通过 carchive的“>>”和“<<”运算符 m_pother->serialize( ar ); // call serialize on objects of known exact type.

从 cobject 派生类

生类，可获得对 cobject 的序列化协议及功能的访问权限。

在 cobject 类中定义了基本的序列化协议和功能。正如在 cperson 类的

// serialize dynamic members and other raw data

if ( ar.isstoring() ) {

ar << m_pobdyn; // store other members

重写 serialize 成员函数

在 cobject 类中定义的 serialize 成员函数实际上负责对捕获对象的当

数，该函数使用其来读写对象数据。 carchive 对象具有成员函数 isstor

正在加载（即正在读取数据）。用 isstoring 的结果作为参考，使用输出

(>>) 提取数据。 也可使用 carchive::read及 carchive::write成员函数来读写大量未

假定一个类是从 cobject 派生的并具有两个新成员变量，使用分别为 declare_serial cstring 和 word 宏 类型。下列类声明段显示了新成员变量和重写成员函数的声明：

class cperson : public cobject { public:

declare_serial( cperson ) // empty constructor is necessary cperson(){};

cstring m_name; word m_number;

void serialize( carchive& archive );

// rest of class declaration };

重写 serialize 成员函数

调用 serialize 的基类版本以确保序列化对象的继承部分。

插入或提取您的类所特定的成员变量。

implement_serial( cperson, cobject, 1 ) 输出运算符及输入运算符与存档类交互作用以读写数据。下面的示例显示了如何实现以上声明的 cperson类的 serialize：

carchiveexception，防止程序读取对象的不正确版本。

在支持序列化的类的声明中需要 declare_serial宏，如下所示：

class cperson : public cobject { declare_serial(

定义不带参数的构造函数 成员变量。

反序列化对象（从磁盘上加载）后，mfc 重新创建这些对象时，需要一个

可将该构造函数声明为公共的、受保护的或私有的。如果使该构造函数成为须使对象处于这样一种状态：必要时，可允许将其安全删除。

注意 如果忘记在使用 declare_serial 及 implement_serial 宏的类得到 “ 没有可用的默认构造函数 ” 编译器警告。 在实现文件中使用 implement_serial 宏 类名和直接基类的名称。

implement_serial 宏用于定义从 cobject中派生可序列化类时所需的各种

该宏的第三个参数是架构编号。架构编号实质上是类对象的版本号。架构编淆。）

mfc 序列化代码在将对象读取到内存时检查该架构编号。如果磁盘上对象

如果要使 serialize成员函数能够读取多个版本（即，读取用应用程序的

implement_serial宏的参数。有关用法信息和示例，请参见 carchive类

以下示例显示了如何将 implement_serial用于从 cobject派生的 cpers

正如序列化：序列化对象文章中所讨论的，一旦具有可序列化的类，就

void cperson::serialize( carchive & archive ) { // call base class function first // base cla

序列化 ：序列化对象 in this case cobject::serialize( archive ); // now do the stuff for our specific class if

序列化：创建可序列化的类 一文说明如何使类可序列化。一旦具有可序列( archive.isstoring() ) archive << m_name << m_number; else archive >> m_name >> m_n

文件序列化该类的对象。本文将解释： carchive 对象的定义 。 两种方法创建 carchive 。

使用 carchive << 和 >> 运算符的方法 。 通过存档存储和加载 cobjects 。

对象。

因此，如果让框架为文档创建 carchive 对象，您所要做的一切是实现写

serialize 函数直接或间接依次序列化的任何 cobject 派生对象实现 se显式创建 carchive 对象

可使框架创建可序列化文档的存档或自己显式创建 carchive对象。通过使用 carchive的“<<”和“>>”运算符或在某些情况下

除了通过框架将文档序列化之外，在其他场合也可能需要 carchive 对象cobject派生类的 serialize 函数，可在文件和可序列化对象间传输数据。 什么是archive对象？

框架采用的相同方式来执行此操作。

象表示。或者，可能要使用用户界面来保存与框架提供的文件不同的文件。

carchive 对象提供了一个类型安全缓冲机制，用于将可序列化对象写入 cfile对象或从中读取可序列化对象。通常，cfile对象表显式创建 carchive 对象 但是，它也可以是表示“剪贴板”的内存文件（csharedfile对象）。

构造 cfile 对象或从 cfile 导出的对象。 给定的 carchive对象要么存储数据（即写入数据或将数据序列化），要么加载数据（即读取数据或将数据反序列化），但决不能同时进

对象的寿命只限于将对象写入文件或从文件读取对象的一次传递。因此，需要两个连续创建的 carchive对象将数据序列化到文件按照下面示例所示，将 cfile 对象传递到 carchive 的构造函数：

反序列化数据。

cfile thefile;

当存档将对象存储到文件时，存档将 cruntimeclass名称附加到这些对象。然后，当另一个存档将对象从文件加载到内存时，将

的 cruntimeclass动态地重新构造 cobject派生的对象。通过存储存档将给定对象写入文件时，该对象可能被引用多次。然而，

thefile.open(..., cfile::modewrite);

对该对象重新构造一次。有关存档如何将 cruntimeclass信息附加到对象以及重新构造对象（考虑可能的多次引用）的详细信息说明 2 。

carchive archive(&thefile, carchive::store);

将数据序列化到存档时，存档积累数据，直到其缓冲区被填满为止。然后，存档将其缓冲区写入 carchive对象指向的 cfile对象

carchive 构造函数的第二个参数是指定存档将用于向文件中存储数据还是

从存档中读取数据时，存档会将数据从文件读取到它的缓冲区，然后从缓冲区读取到反序列化的对象。这种缓冲减少了物理读取硬

档对象的 isstoring 函数来检查该状态。

而提高了应用程序的性能。 创建 carchive 对象有两种方法：

l 通过框架隐式创建 carchive 对象 l 显式创建 carchive 对象 通过框架隐式创建 carchive 对象

以下示例阐释了如何关闭 carchive 对象：

最普通且最容易的方法是使框架代表“文件”菜单上的“保存”、“另存为”和“打开”命令为文档创建 carchive 对象。 archive.close();

以下是应用程序的用户从“文件”菜单上发出“另存为”命令时，框架所执行的操作：

thefile.close();

显示“另存为”对话框并从用户获取文件名。

打开用户命名的文件作为 cfile 对象。

当完成向 carchive 对象存储数据或从该对象中加载数据时，关闭该对象

好的做法是显式执行，因为这使从错误恢复更为容易。有关错误处理的更关闭 carchive 对象

使用 carchive 对象的“ << ”和“ >> ”操作符

创建指向该 cfile 对象的 carchive 对象。在创建 carchive 对象时，框架将模式设置为“存储”（即写入或序列化），而不是读取或反序列化）。

carchive 提供“ << ”和“ >> ”运算符，用于向文件中写入简单的数据

调用在 cdocument 派生类中定义的 serialize 函数，将 carchive 对象的引用传递给该函数。 通过存档将对象存储在文件中

然后，文档的 serialize 函数将数据写入 carchive 对象（刚作了解释）。从 serialize 函数返回时，框架先销毁 carchive 对象，

以下示例显示了如何通过存档将对象存储在文件中： // todo: add loading code here carchive ar(&thefile, carchive::store); word wemployeeid; ...

ar << wemployeeid;

void cperson:serialize(carchive& ar)

从先前存储在文件中的值加载对象

{

以下示例显示了如何从先前存储在文件中的值加载对象：

if (ar.isstoring())

carchive ar(&thefile, carchive::load);

{

word wemployeeid;

ar << m_strname;

...

ar << m_wage;

ar >> wemployeeid;

} } }

上面的代码模板与 appwizard 为该文档（从 cdocument 派生的类）的 s总是并行，该代码模板有助于写的代码更容易复查，如下例中所示：

通常，通过 cobject 派生类的 serialize 函数中的存档将数据存储到文件中或从文件中加载数据，必须已用 declare_serializ件中加载数据或将数据存储到文件中。

{

可序列化的 cobject 派生类的 serialize 函数通常具有以下形式：

ar >> m_strname;

void cperson::serialize(carchive& ar)

ar >> m_wage;

{

}

cobject::serialize(ar);

}

if (ar.isstoring()) {

cobject*

// todo: add storing code here } else {

size 和 csize float word cstring

point 和 cpoint dword

些函数。将 carchive 对象的引用传递到 serialize 函数。调用 else carchive 对象的 isloading 函数以确定是否已调用 serializ

库将 carchive 的“ << ”和“ >> ”运算符定义为第一操作数，将下列

byte

rect 和 crect double long

ctime 和 ctimespan int

colecurrency colevariant

coledatetime coledatetimespan

l 在 view 类中添加对控件的响应，实现画图功能，每次鼠标弹l 保存文件（通过 doc 的 serialize 来保存数据）

l 打开文件（通过 doc 的 serialize 来读取数据，并将其重绘在 view 类中定义 cobarray m_obarray;

下面按这个思路来完成：（在 c graph 子类中完成重绘的画图功能） graph.cpp

#include \#include \

implement_serial(cgraph, cobject, 1 )

cgraph::cgraph(void)

注意 通过存档存储及加载 cobjects 需要额外注意。有关更多信息，请参见通过存档存储和加载 cobjects 。

: m_ptorigin(0)

carchive 的“ << ”和“ >> ”运算符总是返回 carchive 对象的引用，该引用为第一操作数。这使您可以链接运算符，如下所

, m_ptend(0)

byte bsomebyte;

, m_ndrawtype(0)

word wsomeword;

{

dword wsomedoubleword;

}

...

cgraph::cgraph(cpoint m_ptorigin,cpoint m_ptend,uint m_ndrawtype

ar << bsomebyte << wsomeword << wsomedoubleword;

{

this->m_ptorigin=m_ptorigin;

this->m_ptend=m_ptend;

通过存档存储及加载 cobject （见前）

this->m_ndrawtype=m_ndrawtype;

下面用一个示例来解释这个问题。

}

目标：一个画图程序，通过保存打开按钮存取图片。方法：保存图片绘制信息。

cgraph::~cgraph(void)

按步骤：

{

l 创建可序列化的类 ->graph.cpp+graph.h

}

void cgraph::serialize( carchive& ar ) {

// 继承基类的cobject cobject::serialize( ar ); if( ar.isstoring() ) {

case 2:

pdc->moveto(m_ptorigin); pdc->lineto(m_ptend); break; case 3:

pdc->rectangle(crect(m_ptorigin,m_ptend)); break;

ar << m_ptorigin << m_ptend << m_ndrawtype ; case 4: } else {

pdc->ellipse(crect(m_ptorigin,m_ptend)); break; }

ar >> m_ptorigin >> m_ptend >> m_ndrawtype ; pdc->selectobject(poldbrush); } }

void cgraph::draw(cdc* pdc) {

} graph..h #pragma once

#include \

cbrush *pbrush=cbrush::fromhandle((hbrush)getstockobject(null_brush)); cbrush *poldbrush=pdc->selectobject(pbrush); class cgraph : publiccobject switch(m_ndrawtype) { case 1:

pdc->setpixel(m_ptend,rgb(0,0,0)); break;

{ public :

declare_serial( cgraph ) cgraph(void);

cgraph::cgraph(cpoint m_ptorigin,cpoint m_ptend,uint m_ndra

void serialize( carchive& ar ); ~cgraph(void); cpoint m_ptorigin; cpoint m_ptend; uint m_ndrawtype; void draw(cdc* pdc); };

在 view 类中添加画图功能 void cgraphicserialview::ondot() {

// todo: 在此添加命令处理程序代码 m_ndrawtype=1; }

void cgraphicserialview::online() {

// todo: 在此添加命令处理程序代码 m_ndrawtype=2; }

void cgraphicserialview::onrectangle() {

// todo: 在此添加命令处理程序代码

m_ndrawtype=3; }

void cgraphicserialview::onellipse() {

// todo: 在此添加命令处理程序代码 m_ndrawtype=4; }

void cgraphicserialview::onlbuttondown(uint nflags, cpoint point{

// todo: 在此添加消息处理程序代码和/或调用默认值 m_ptorigin = point;

cview::onlbuttondown(nflags, point); }

void cgraphicserialview::onlbuttonup(uint nflags, cpoint point) {

// todo: 在此添加消息处理程序代码和/或调用默认值 cclientdc dc(this);

cbrush *pbrush=cbrush::fromhandle((hbrush)getstockobject(nu dc.selectobject(pbrush);

switch(m_ndrawtype) { case 1:

dc.setpixel(point,rgb(0,0,0)); break; case 2:

dc.moveto(m_ptorigin);

但是要保存和读取文件需要用到 serialize 因此转到 doc 类

void cgraphicserialdoc::serialize(carchive& ar) {

position pos=getfirstviewposition();// 获得第一个视类对象在

cgraphicserialview *pview=(cgraphicserialview*)getnextview(p类对象

if (ar.isstoring())

dc.lineto(point);

{

break;

// todo: 在此添加存储代码

case 3:

int ncount=pview->m_obarray.getsize();

dc.rectangle(m_ptorigin.x,m_ptorigin.y,point.x,point.y); break;

for(int i=0;i

case 4:

{

dc.ellipse(crect(m_ptorigin,point));

ar<m_obarray.getat(i);

break;

}

default:

}

break;

else

}

{

// 将图形信息保存起来

// todo: 在此添加加载代码 int ncount;

m_obarray.add(pgraph);// 将一群这样的pgraph组织在一起放进m_obarray

ar>>ncount;

cview::onlbuttonup(nflags, point);

cgraph *pgraph;

}

ar<

cgraph *pgraph=new cgraph( m_ptorigin , point , m_ndrawtype ); // 创建一个pgraph指针指向一个存储图形信息的

for(int i=0;i

ar>>pgraph;

pview->m_obarray.add(pgraph); } } }

类对象

if (ar.isstoring()) {

// todo: 在此添加存储代码 } else {

但是读取数据的时候还需要重绘图像：转回view类，因为在 // todo: view类加载的时候会自动调用在此添加加载代码ondraw(), 在ondraw()中添加如下语句 int ncount;

ncount=m_obarray.getsize(); for(int i=0;i

}

pview->m_obarray.serialize(ar); // 将这个数据传递给 }

其中cobarray类对象读取数据的方法：（以下是mfc源代码，无须用户添

((cgraph*)m_obarray.getat(i))->draw(pdc); void cobarray::serialize(carchive& ar) }

基本上完成了通过serialize保存和打开文件。

{

assert_valid(this);

用serialize的好处：通过缓存来保存，当缓存区满了才进行一次读 /写，因此提高了应用程序的效率

cobject::serialize(ar);

另外 ， archive 对象是支持序列化的，因此在读写数据的时候即可以按以上方法在 doc 类的 serialize 来保存和打开数据。 因此修改 doc 中的 serialize 为

if (ar.isstoring())

void cgraphicserialdoc::serialize(carchive& ar) { {

ar.writecount(m_nsize);

position pos=getfirstviewposition();// 获得第一个视类对象在对象列表中的位置 for (int_ptr i = 0; i < m_nsize; i++)

cgraphicserialview *pview=(cgraphicserialview*)getnextview(pos);// ar << m_pdata[i]; 找到当前视类对象的指针，由于这是单文档，因

} else {

} }

void cgraphicserialdoc::serialize(carchive& ar)

dword_ptr noldsize = ar.readcount(); { setsize(noldsize);

??

for (int_ptr i = 0; i < m_nsize; i++) m_obarray.serialize(ar); //doc 类中定义m_obarray的情况 ar >> m_pdata[i]; } }

void cgraphicserialdoc::deletecontents()

下面直接在 doc 类中使用 cobarray 对象（取消之前定义在 view 类中的该类对象）

{

在 doc 类中定义 cobarray m_obarray;

int ncount;

存图形数据的代码修改为：

ncount=m_obarray.getsize();

cgraphicdoc *pdoc=getdocument();// 通过视类提供的getdocument()方法来获得doc类指针

/*for(int i=0;i

pdoc->m_obarray.add(pgraph);

{

修改其他位置的 m_obarray

delete m_obarray.getat(i);

void cgraphicserialview::ondraw(cdc* pdc)

//m_obarray.removeat(i);

{

}

??

m_obarray.removeall();*/

ncount=pdoc->m_obarray.getsize();

while(ncount--)

for(int i=0;i

{

{

delete m_obarray.getat(ncount);

((cgraph*)pdoc->m_obarray.getat(i))->draw(pdc); //doc类中定义m_obarray的情况

}

当我们新建和打开文档的时候，我们之前的文档对象并没有被销毁（系统利此时应删除文档对象。

在文档类中重载函数 void cgraphicserialdoc::deletecontents() 来删

m_obarray.removeat(ncount); }

cdocument::deletecontents(); }

本文来源：https://www.bwwdw.com/article/4uzg.html