Visual C++中对象的序列化与文件I/O研究

最新推荐文章于 2024-01-03 15:19:22 发布
最新推荐文章于 2024-01-03 15:19:22 发布
阅读量509 收藏
点赞数
分类专栏： MFC 文章标签： c++ mfc 文档 磁盘 file 存储

持久性是对象所有的保存和加载其状态数据的能力。具有这种能力的对象能够在应用程序结束之前以某种方式将当前的对象状态数据记录下来，当程序再次运行时，通过对这些数据的读取而恢复到上一次任务结束时的状态。由于绝大多数的MFC类是直接或间接由MFC的CObject类派生出来的，因此这些MFC类都具有保存和加载对象状态的能力，是具有持久性的。在使用应用程序向导生成文档/视结构的程序框架时，就已经为应用程序提供了用于对象状态数据保存和加载的基本代码。
 
　　为实现对象的持久性，通常多以字节流的形式将记录对象状态的数据存放到磁盘上，这种将状态数据保存到磁盘和从磁盘恢复到内存的过程称为序列化。序列化是MFC的一个重要概念，是MFC文档/视图结构应用程序能进行文档打开、保存等操作的基础。当在MFC框架程序中装载或保存一个文件时，除了打开文件以供程序读写外，还传递给应用程序一个相关的CArchive对象，并以此实现对持久性数据的序列化。
 
　　大多数MFC应用程序在实现对象的持久性时并非直接用MFC的CFile类对磁盘文件进行读写（有关CFile类的详细介绍将在下一节进行），而是通过使用CArchive对象并由其对CFile成员函数进行调用来执行文件I/O操作。CArchive类支持复合对象的连续二进制形式的输入输出。在构造一个CArchive对象或将其连接到一个表示打开的文件的CFile对象后，可以指定一个档案是被装载还是被保存。MFC允许使用操作符“<<”和“>>”来对多种原始数据类型进行序列化。这些原始数据类型包括BYTE，WORD，LONG，DWORD，float，double，int，unsigned int，short和char等。
 
 
　　对于其他由MFC类来表示的非原始数据类型如CString对象等的序列化则可以通过对“<<”和“>>”运算符的重载来解决，可以用此方式进行序列化的MFC类和结构有CString，CTime，CTimeSpan，COleVariant，COleCurreny，COleDateTime，COleDateTimeSpan，CSize，CPoint，CRect，SIZE，POINT和RECT等。除了操作符“<<”和“>>”之外还可以调用CArchive类成员函数Read（）和Write（）来完成序列化。下面这段代码展示了通过操作符对int型变量VarA、VarB的序列化过程：
 
// 将VarA、VarB存储到档案中
CArchive ar (&file, CArchive::store);
ar << VarA << VarB;
……
// 从档案装载VarA、VarB
CArchive ar (&file, CArchive::load)
ar >> VarA >> VarB;
 
　　CArchive类仅包含有一个数据成员m__pDocument。在执行菜单上的打开或保存命令时，程序框架将会把该数据成员设置为要被序列化的文档。另外需要特别注意的是：在使用CArchive类时，要保证对CArchive对象的操作与文件访问权限的统一。
 
　　在本文下面将要给出的示例程序中，将对绘制连线所需要的关键点坐标和坐标个数等持久性对象进行序列化。其中文档类的成员变量m_nCount和m_ptPosition[100]分别记录了当前点的个数和坐标，初始值为0。当鼠标点击客户区时将对点的个数进行累加，并保存当前点的坐标位置。随后通过Invalidate（）函数发出WM_PAINT消息通知窗口对客户区进行重绘，在重绘代码中对这些点击过的点进行绘图连线：
 
 
void CSample04View::OnLButtonDown(UINT nFlags, CPoint point)
{
　// 获取指向文档类的指针
　CSample04Doc* pDoc = GetDocument();
　// 保存当前鼠标点击位置
　pDoc->m_ptPosition[pDoc->m_nCount] = point;
　if (pDoc->m_nCount < 100)
　　pDoc->m_nCount++;
　// 刷新屏幕
　Invalidate();
　CView::OnLButtonDown(nFlags, point);
}
……
void CSample04View::OnDraw(CDC* pDC)
{
　CSample04Doc* pDoc = GetDocument();
　ASSERT_VALID(pDoc);
　// 对点击的点进行连线绘图
　pDC->MoveTo(pDoc->m_ptPosition[0]);
　for (int i = 1; i < pDoc->m_nCount; i++)
　　pDC->LineTo(pDoc->m_ptPosition[i]);
}
 
 
　　从上述程序代码不难看出，为了能保存绘制结果需要对文档类的成员变量m_nCount和m_ptPosition[100]进行序列化处理。而文档类成员函数Serialize（）则通过Archive类为这些持久性对象的序列化提供了功能上的支持。下面的代码完成了对持久性对象的保存和加载：
 
if (ar.IsStoring())
{
　// 存储持久性对象到档案
　ar << m_nCount;
　for (int i = 0; i < m_nCount; i++)
　　ar << m_ptPosition[i];
}
else
{
　// 从档案装载持久性对象
　ar >> m_nCount;
　for (int i = 0; i < m_nCount; i++)
　　ar >> m_ptPosition[i];
}
自定义持久类
 
　　为了使一个类的对象成为持久的，可以自定义一个持久类，将持久性数据的存储和加载的工作交由自定义类自己去完成。这种处理方式也更加符合面向对象的程序设计要求。可以通过下面几个基本步骤来创建一个能序列化其成员变量的自定义持久类：
 
　　1． 直接或间接从CObject类派生出一个新类。
 
　　2． 在类的声明部分包含MFC的DECLARE_SERIAL宏，该宏只需要将类名作为参数。
 
　　3． 重载基类的Serialize（）函数，并添加对数据成员进行序列化的代码。
 
　　4． 如果构造函数没有一个空的缺省的构造函数（不含任何参数），为其添加一个。
 
　　5． 在类的实现部分，添加MFC的IMPLEMENT_SERIAL宏。该宏需要三个参数：类名，基类名和一个方案号。其中方案号是一个相当于版本号的整数，每当改变了类的序列化数据格式后就应当及时更改此数值。
根据上述步骤不难对上一小节中的序列化代码进行封装，封装后的持久类CPosition负责对类成员变量m_nCount和m_ptPosition[100]的序列化，封装后的代码如下：
 
// CPosition类声明部分：
class CPosition : public CObject
{
　DECLARE_SERIAL(CPosition)
　CPosition();
　int m_nCount;
　CPoint m_ptPosition[100];
　void Serialize(CArchive& ar);
　CPoint GetValue(int index);
　void SetValue(int index, CPoint point);
　virtual ~CPosition();
};
……
// CPosition类实现部分：
IMPLEMENT_SERIAL(CPosition, CObject, 0)
CPosition::CPosition()
{
　// 对类成员进行初始化
　m_nCount = 0;
　for (int i = 0; i < 100; i++)
　　m_ptPosition[i] = CPoint (0, 0);
}
CPosition::~CPosition()
{
}
void CPosition::SetValue(int index, CPoint point)
{
　// 设置指定点的坐标值
　m_ptPosition[index] = point;
}
CPoint CPosition::GetValue(int index)
{
　// 获取指定点的坐标值
　return m_ptPosition[index];
}
void CPosition::Serialize(CArchive &ar)
{
　CObject::Serialize(ar);
　if (ar.IsStoring())
　{
　　// 存储持久性对象到档案
　　ar << m_nCount;
 
 
输入您的搜索字词 提交搜索表单         
 
 
　　for (int i = 0; i < m_nCount; i++)
　　ar << m_ptPosition[i];
　}
　else
　{
　　// 从档案装载持久性对象
　　ar >> m_nCount;
　　for (int i = 0; i < m_nCount; i++)
　　　ar >> m_ptPosition[i];
　}
}
 
　　在创建了自定义持久类CPosition后，可以通过该类对鼠标点击过的点的坐标进行管理，由于序列化的工作已由类本身完成，因此只需在文档类的Serialize（）函数中对CPosition的Serialize（）成员函数进行调用即可：
 
void CSample04Doc::Serialize(CArchive& ar)
{
　// 使用定制持久类
　m_Position.Serialize(ar);
　if (ar.IsStoring())
　{
　}
　else
　{
　}
}
文件I/O
 
　　虽然使用CArchive类内建的序列化功能是保存和加载持久性数据的便捷方式，但有时在程序中需要对文件处理过程拥有更多的控制权，对于这种文件输入输出（I/O）服务的需求，Windows提供了一系列相关的API函数，并由MFC将其封装为CFile类，提供了对文件进行打开，关闭，读，写，删除，重命名以及获取文件信息等文件操作的基本功能，足以处理任意类型的文件操作。CFile类是MFC文件类的基类，支持无缓冲的二进制输入输出，也可以通过与CArchive类的配合使用而支持对MFC对象的带缓冲的序列化。
 
　　CFile类包含有一个公有型数据成员m_hFile，该数据成员包含了同CFile类对象相关联的文件句柄。如果没有指定句柄，则该值为CFile::hFileNull。由于该数据成员所包含的意义取决于派生的类，因此一般并不建议使用m_hFile。
 
　　通过CFile类来打开文件可以采取两种方式：一种方式是先构造一个CFile类对象然后再调用成员函数Open（）打开文件，另一种方式则直接使用CFile类的构造函数去打开一个文件。下面的语句分别演示了用这两种方法打开磁盘文件“C:/TestFile.txt”的过程：
 
// 先构造一个实例，然后再打开文件
CFile file;
file.Open(“C://TestFile.txt”, CFile::modeReadWrite);
……
// 直接通过构造函数打开文件
CFile file(“C://TestFile.txt”, CFile::modeReadWrite);
 
　　其中参数CFile::modeReadWrite是打开文件的模式标志，CFile类中与之类似的标志还有十几个，现集中列表如下：
 
文件模式标志 说明
CFile::modeCreate 创建方式打开文件，如文件已存在则将其长度设置为0
CFile::modeNoInherit 不允许继承
CFile::modeNoTruncate 创建文件时如文件已存在不对其进行截断
CFile::modeRead 只读方式打开文件
 
 
CFile::modeReadWrite 读写方式打开文件
CFile::modeWrite 写入方式打开文件
CFile::shareCompat 在使用过程中允许其他进程同时打开文件
CFile::shareDenyNone 在使用过程中允许其他进程对文件进行读写
CFile::shareDenyRead 在使用过程中不允许其他进程对文件进行读取
CFile::shareDenyWrite 在使用过程中不允许其他进程对文件进行写入
CFile::shareExclusive 取消对其他进程的所有访问
CFile::typeBinary 设置文件为二进制模式
CFile::typeText 设置文件为文本模式
 
　　这些标志可以通过“或”运算符而同时使用多个，并以此来满足多种需求。例如，需要以读写方式打开文件，如果文件不存在就创建一个新的，如果文件已经存在则不将其文件长度截断为0。为满足此条件，可用CFile::modeCreate、CFile::modeReadWrite和CFile::modeNoTruncate等几种文件模式标志来打开文件：
 
CFile file ("C://TestFile.txt", CFile::modeCreate | CFile::modeReadWrite | CFile::modeNoTruncate);
 
　　在打开的文件不再使用时需要将其关闭，即可以用成员函数Close（）关闭也可以通过CFile类的析构函数来完成。当采取后一种方式时，如果文件还没有被关闭，析构函数将负责隐式调用Close（）函数去关闭文件，这也表明创建在堆上的CFile类对象在超出范围后将自动被关闭。由于调用了对象的析构函数，因此在文件被关闭的同时CFile对象也被销毁，而采取Close（）方式关闭文件后，CFile对象仍然存在。所以，在显式调用Close（）函数关闭一个文件后可以继续用同一个CFile对象去打开其他的文件。
 
 
 
　　文件读写是最常用的文件操作方式，主要由CFile类成员函数Read（）、Write（）来实现。其函数原型分别为：
 
UINT Read( void* lpBuf, UINT nCount );
void Write( const void* lpBuf, UINT nCount );
 
　　参数lpBuf为指向存放数据的缓存的指针，nCount为要读入或写入的字节数，Read（）返回的为实际读取的字节数，该数值小于或等于nCount，如果小于nCount则说明已经读到文件末尾，可以结束文件读取，如继续读取，将返回0。因此通常可以将实际读取字节数是否小于指定读取的字节数或是否为0作为判断文件读取是否到达结尾的依据。下面这段代码演示了对文件进行一次性写入和循环多次读取的处理过程：
 
// 创建、写入方式打开文件
CFile file;
file.Open("C://TestFile.txt", CFile::modeWrite | CFile::modeCreate);
// 写入文件
memset(WriteBuf, 'a', sizeof(WriteBuf));
file.Write(WriteBuf, sizeof(WriteBuf));
// 关闭文件
file.Close();
// 只读方式打开文件
file.Open("C://TestFile.txt", CFile::modeRead);
while (true)
{
// 读取文件数据
int ret = file.Read(ReadBuf, 100);
……
// 如果到达文件结尾则中止循环
if (ret < 100)
break;
}
// 关闭文件
file.Close();
 
　　Write（）和Read（）函数执行完后将自动移动文件指针，因此不必再显示调用Seek（）函数去定位文件指针。包含有文件定位函数的完整代码如下所示：
 
// 创建、写入方式打开文件
CFile file;
file.Open("C://TestFile.txt", CFile::modeWrite | CFile::modeCreate);
// 写入文件
memset(WriteBuf, 'a', sizeof(WriteBuf));
file.SeekToBegin();
file.Write(WriteBuf, sizeof(WriteBuf));
// 关闭文件
file.Close();
// 只读方式打开文件
file.Open("C://TestFile.txt", CFile::modeRead);
while (true)
{
// 文件指针
static int position = 0;
// 移动文件指针
file.Seek(position, CFile::begin);
// 读取文件数据
int ret = file.Read(ReadBuf, 100);
position += ret;
……
// 如果到达文件结尾则中止循环
if (ret < 100)
break;
}
// 关闭文件
file.Close();
 
　　小结
 
　　持久性和文件I/O是程序保持和记录数据的一种重要方法，这两种不同的处理方法虽然功能上有些接近但实现过程却大不相同。而且这两种处理方法各有优势，读者在编程过程中应根据实际情况而灵活选用。 
此信息来自<立珊网络计算机专业网>,立珊网络计算机专业网站.http://www.lis123.com 原文链接： http://www.lis123.com/Article/Dev/Programme/Visual_Basic/20071205_6282.html
 
 
 
 
  1. // CGuideMapView 构造/析构
  2. CGuideMapView::CGuideMapView()
  3. {
  4.     CoInitializeEx(NULL, COINIT_MULTITHREADED);
  5.     CreateDir();
  6.     m_pAddress = new GPS;
  7.     //载入mapshape
  8.     CFile stateFile; 
  9.     CFileException ex;
  10.     if (stateFile.Open(gDir.m_RootDir + _T("//mapshape"), CFile::modeRead | CFile::typeBinary, &ex) == 0)
  11.     {
  12.         if(ex.m_cause == CFileException::fileNotFound) return;//没有相关文件，是由于是第一次运行。
  13.         TCHAR szError[1024];
  14.         ex.GetErrorMessage(szError, 1024);
  15.         AfxMessageBox(szError);
  16.         return;
  17.     }
  18.     else
  19.     {
  20.         TRY 
  21.         {
  22.             CArchive ar(&stateFile, CArchive::load);
  23.             m_MapShape.Serialize(ar);
  24.             ar.Close();
  25.             stateFile.Close();
  26.         }
  27.         CATCH (CException, e)
  28.         {
  29.             TCHAR szError[1024];
  30.             e->GetErrorMessage(szError, 1024);
  31.             AfxMessageBox(szError);
  32.         }
  33.         END_CATCH
  34.     }
  35. }
  37. CGuideMapView::~CGuideMapView()
  38. {
  39.     if (m_pAddress != NULL)
  40.     {
  41.         delete m_pAddress;
  42.     }
  43.     if ( m_MapShape.PreSet(_T("玉泉"), _T("1.0,2.0;2.55,3.26;5,77.2;0,0;")) != true)
  44.     {
  45.         AfxMessageBox(_T("error"));
  46.     }
  47.     
  48.     m_MapShape.Set();
  49.     
  50.     //保存mapshape
  51.     CFileException ex;
  52.     CFile stateFile; 
  53.     if (stateFile.Open(gDir.m_RootDir + _T("//mapshape"), CFile::modeCreate | CFile::modeWrite | CFile::typeBinary | CFile::shareExclusive, &ex) == 0)//CFile::Open()不会throw错误。
  54.     {
  55.         TCHAR szError[1024];
  56.         ex.GetErrorMessage(szError, 1024);
  57.         AfxMessageBox(szError);
  58.         return;
  59.     }
  60.     else
  61.     {
  62.         TRY 
  63.         {
  64.             CArchive ar(&stateFile, CArchive::store);
  65.             m_MapShape.Serialize(ar);
  66.             //ar.Flush();
  67.             ar.Close();//这1句一定要加，不加就出错了，不加时，发现CArchive的自动析构会调用CArchive的Close，Close又调用其自身的Fluch，但就是会出错
  68.             //stateFile.Flush();
  69.             stateFile.Close();
  71.         }
  72.         CATCH (CException, e)
  73.         {
  74.             TCHAR szError[1024];
  75.             e->GetErrorMessage(szError, 1024);
  76.             AfxMessageBox(szError);
  77.         }
  78.         END_CATCH
  80.     }
  81.     CoUninitialize();
  82. }
DOOM
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VC程序设计中可序列化类的实现
weixin_30776863的博客
10-10 164
内容提要：本文以简单的例子介绍在Visual C++编程中数据读写的基本方法和可序列化类的实现，并简单介绍了Visual C++中序列化的使用。 　　数据读写是应用程序中必不可少的一部分，Visual C++中数据的读写当然也十分重要，因此VisualC++在MFC中对数据的读写创造了十分好的支持，这使得我们可以十分方便的实现我们对数据读写操作的需要。　　MFC 为数据读写设计了...
字节跳动高性能C++实践|高效JSON库
极客重生
12-20 1984
sonic-cpp 是由字节跳动 STE 团队和服务框架团队共同研发的一款面向 C++ 语言的高效 JSON 库，极致地利用当前 CPU 硬件特性与向量化编程，大幅提高了序列化反序列化性能，解析性能为 rapidjson 的 2.5 倍。sonic-cpp 在字节内部上线以来， 已为抖音、今日头条等核心业务，累计节省了数十万 CPU 核心。今天我们正式对外开源 sonic-cpp，希望能够帮助更多...
AC——c++数据序列化方案
木易杨的博客
10-07 1118
1 背景 AC(Auto Converter)是一款轻量级的基于c++开发的数据序列化开发框架。框架基于纯c++开发，开箱即用，无三方依赖库。由于c/c++语言没有类似java\python等到高级语言获取对象的metadata的功能, 在数据序列化时需要针对具体的数据对象开发序列化代码，开发起来比较复杂且容易出错。 AC框架借鉴java中Object的思想，定义超类AutoConverter...
C/C++框架和库推荐
红军不怕远征难，万水千山只等闲
01-03 1300
包括了STL容器，算法和函数等。：是一系列类和函数的集合，使用核心语言编写，也是C++ISO自身标准的一部分。：标准模板库： POSIX系统的C标准库规范e ：C++标准委员会。
Visual C++中对象的序列化与文件I-O研究.rar_c++对象序列化_对象序列化_序列化
09-19
通过上述方法，你可以在Visual C++环境中实现对象的序列化与文件I/O，有效地存储和恢复程序的状态。提供的3.txt、1.txt、2.txt和www.pudn.com.txt文件可能包含更多关于这一主题的详细示例和解释，建议进一步查阅这些...
极简风格快速处理序列化与反序列化 C++ 11 C++20 测试及代码实现工程文件
最新发布
02-18
在C++编程中，序列化和反序列化是两个重要的概念，它们主要用于将数据结构或对象的状态转换为可存储或可传输的形式，然后再恢复回原始状态。这些过程在很多场景下都非常有用，例如持久化存储、网络通信以及跨进程...
Visual C++源代码 124 如何以二进制格式序列化数据集
06-19
Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集Visual C++源代码 124 如何以二进制格式序列化数据集...
ABC.rar_文件格式_Visual_C++_
08-11
同时，C++也支持自定义文件格式，通过序列化和反序列化技术将数据结构转换为可存储或传输的格式，如JSON、XML或二进制格式。 2. **Visual C++的特性**：Visual C++不仅提供了代码编辑器，还包括编译器、调试器、...
VS、VC++实现对象序列化保存到sqlite表blob类型字段中，包含blob字段的读取和保存，
04-04
VS、VC++实现对象序列化保存到sqlite表blob类型字段中，包含blob字段的读取和保存，文档中有代码及说明实例。
VC序列化-存储文件方法
06-12
VC序列化-存储文件方法，可用于系统配置，或者系统状态的保存
C++CArchive序列化存储
10-17
CArchive类的简单用法，实现C++序列化和反序列化存储，简单明了
C++数据序列化之MessagePack
sky_0035的专栏
01-21 3400
msgpack官方地址：http://msgpack.org/ msgpack GITHUB地址：https://github.com/msgpack 对于msgPack,官方是这样解释的： MessagePack  是一个高效的二进制序列化格式。它让你像JSON一样可以在各种语言之间交换数据。但是它比JSON更快、更小。小的整数会被编码成一个字节，短的字符串仅仅只需要比它的长度多一
C++与序列化
weixin_43728590的博客
06-15 3479
协议/protobuf
使用C++进行对象序列化
Everything is possible--博客的内容只是作为一种备忘
03-09 1047
什么是序列化 程序员在编写应用程序的时候往往需要将程序的某些数据存储在内存中，然后将其写入某个文件或是将它传输到网络中的另一台计算机上以实现通讯。这个将程序数据转化成能被存储并传输的格式的过程被称为“序列化”（Serialization），而它的逆过程则可被称为“反序列化”（Deserialization）。 简单来说，序列化就是将对象实例的状态转换为可保持或传输的格式的过程。与序列化...
C++ 序列化
08-15 1861
转自:http://blog.csdn.net/pandaxcl/archive/2006/04/03/649682.aspx #if 0     在用C++编写应用程序的过程中，经常涉及到序列化的问题，但是序列化的问题通常都 会有非常繁琐的过程代码需要书写，本文中就是
C++实现对象序列化和反序列化（读写二进制文件）操作
重庆李四
03-13 6456
相关函数介绍在我们的C语言中读写二进制文件一般使用的fread、fwrite全局函数，当然也可以使用更底层的read和write函数。在我们的C++中 通过ofstream 和 ifstream 对象 读写文件更加的方便了。对二进制文件的读写 主要使用ofstream::write，ifstream::read函数。如果对文件读写方向感不强，记不住的 ，记住4个字就行了。读入写出。这个4个字是针...
C++ 序列化反序列化众多方式中的两种
众生本就皆苦的博客
07-07 469
本文举例说明两种序列化方式，第一种是使用自带的文件操作库`ifstream`对类进行二进制序列化及反序列化；第二种采用轻量级的Cereal对类进行序列化及反序列化。
Visual C++2010入门：序列化与打印文档详解
在MFC编程中，序列化是一项关键的技术，它允许程序将复杂的类对象存储到文件中，并能从文件中恢复这些对象。由于类对象包含数据成员和函数成员，且有访问权限控制，因此直接写入文件并简单读取是不够的。MFC通过引入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值