MFC-CArchive原理

MFC 提供CArchive类实现数据的缓冲区读写，同时定义了类对象的存储与读取方案。 以下对CArchvie 的内部实现作分析。

 

一.概述

CArchive使用了缓冲区，即一段内存空间作为临时数据存储地，对CArchive的读写都先依次排列到此缓冲区，当缓冲区满或用户要求时，将此段整理后的数据读写到指定的存储煤质。
当建立CArchive对象时，应指定其模式是用于缓冲区读，还是用于缓冲区写。
可以这样理解，CArchive对象相当于铁路的货运练调度站，零散的货物被收集，当总量到达火车运量的时候，由火车装运走。
当接到火车的货物时，则货物由被分散到各自的货主。与货运不同的是，交货、取货是按时间循序执行的，而不是凭票据。因此必须保证送货的和取货的货主按同样的循序去存或取。
对于大型的货物，则是拆散成火车单位，运走，取货时，依次取各部分，组装成原物。

 

二.内部数据
缓冲区指针 BYTE* m_lpBufStart,指向缓冲区，这个缓冲区有可能是底层CFile(如派生类CMemFile)对象提供的，但一般是CArchive自己建立的。
缓冲区尾部指针 BYTE* m_lpBufMax;
缓冲区当前位置指针 BYTE* m_lpBufCur;
初始化时，如果是读模式,当前位置在尾部，如果是写模式，当前位置在头部:

    m_lpBufCur = (IsLoading()) ? m_lpBufMax : m_lpBufStart;

三.基本数据读写

对于基本的数据类型，例如字节、双字等，可以直接使用">>"、"<<"符号进行读出、写入。

    //操作符定义捕: 

    //插入操作

    CArchive& operator<<(BYTE by);

    CArchive& operator<<(WORD w);

    CArchive& operator<<(LONG l);

    CArchive& operator<<(DWORD dw);

    CArchive& operator<<(float f);

    CArchive& operator<<(double d);

    CArchive& operator<<(int i);

    CArchive& operator<<(short w);

    CArchive& operator<<(char ch);

    CArchive& operator<<(unsigned u);

    //提取操作

    CArchive& operator>>(BYTE& by);

    CArchive& operator>>(WORD& w);

    CArchive& operator>>(DWORD& dw);

    CArchive& operator>>(LONG& l);

    CArchive& operator>>(float& f);

    CArchive& operator>>(double& d);

    CArchive& operator>>(int& i);

    CArchive& operator>>(short& w);

    CArchive& operator>>(char& ch);

    CArchive& operator>>(unsigned& u);

下面以双字为例，分析原码

双字的插入(写)

    CArchive& CArchive::operator<<(DWORD dw)

    { if (m_lpBufCur + sizeof(DWORD) > m_lpBufMax) //缓冲区空间不够  

    Flush();  //缓冲区内容提交到实际存储煤质。 

    if (!(m_nMode & bNoByteSwap))  

    _AfxByteSwap(dw, m_lpBufCur);  //处理字节顺序 

    else  *(DWORD*)m_lpBufCur = dw;      //添入缓冲区 

    m_lpBufCur += sizeof(DWORD);     //移动当前指针 

    return *this;

    }

双字的提取(读)

    CArchive& CArchive::operator>>(DWORD& dw)

    { if (m_lpBufCur + sizeof(DWORD) > m_lpBufMax) //缓冲区要读完了  

    FillBuffer(sizeof(DWORD) - (UINT)(m_lpBufMax - m_lpBufCur));  //重新读入内容到缓冲区 

    dw = *(DWORD*)m_lpBufCur;  //读取双字 

    m_lpBufCur += sizeof(DWORD); //移动当前位置指针 

    if (!(m_nMode & bNoByteSwap)) 

     _AfxByteSwap(dw, (BYTE*)&dw);  //处理字节顺序 

    return *this;

    }

四.缓冲区的更新

以上操作中，当缓冲区将插入满或缓冲区将提取空时，都将对缓冲区进行更新处理。

缓冲区将插入满时调用Flush();

    void CArchive::Flush()

    { ASSERT_VALID(m_pFile); 

    ASSERT(m_bDirectBuffer || m_lpBufStart != NULL); 

    ASSERT(m_bDirectBuffer || m_lpBufCur != NULL); 

    ASSERT(m_lpBufStart == NULL ||  AfxIsValidAddress(m_lpBufStart, m_lpBufMax - m_lpBufStart, IsStoring())); 

    ASSERT(m_lpBufCur == NULL ||  AfxIsValidAddress(m_lpBufCur, m_lpBufMax - m_lpBufCur, IsStoring()));

     if (IsLoading()) 

    {  

    // unget the characters in the buffer, seek back unused amount  

    if (m_lpBufMax != m_lpBufCur)   

    {m_pFile-> Seek(-(m_lpBufMax - m_lpBufCur), CFile::current); 

     m_lpBufCur = m_lpBufMax;    // 指向尾 

    } 

    else   //写模式 

    {  if (!m_bDirectBuffer) 

     {   // 内容写入到文件  

     if (m_lpBufCur != m_lpBufStart)   

     m_pFile-> Write(m_lpBufStart, m_lpBufCur - m_lpBufStart);  

    }  

    else  {  

     //如果是直接针对内存区域的的(例如CMemFile中) (只需移动相关指针，指向新的一块内存) 

      if (m_lpBufCur != m_lpBufStart)   

     m_pFile-> GetBufferPtr(CFile::bufferCommit, m_lpBufCur - m_lpBufStart);   // get next buffer  

     VERIFY(m_pFile-> GetBufferPtr(CFile::bufferWrite, m_nBufSize,    (void**)&m_lpBufStart, (void**)&m_lpBufMax) == (UINT)m_nBufSize);   

    ASSERT((UINT)m_nBufSize == (UINT)(m_lpBufMax - m_lpBufStart)); 

     } 

     m_lpBufCur = m_lpBufStart; //指向缓冲区首 

    }}

缓冲区将提取空,会调用FillBuffer。 nBytesNeeded为当前剩余部分上尚有用的字节

    void CArchive::FillBuffer(UINT nBytesNeeded)

    { ASSERT_VALID(m_pFile); 

    ASSERT(IsLoading()); 

    ASSERT(m_bDirectBuffer || m_lpBufStart != NULL); 

    ASSERT(m_bDirectBuffer || m_lpBufCur != NULL); 

    ASSERT(nBytesNeeded > 0); 

    ASSERT(nBytesNeeded <= (UINT)m_nBufSize); 

    ASSERT(m_lpBufStart == NULL ||  AfxIsValidAddress(m_lpBufStart, m_lpBufMax - m_lpBufStart, FALSE));

     ASSERT(m_lpBufCur == NULL ||  AfxIsValidAddress(m_lpBufCur, m_lpBufMax - m_lpBufCur, FALSE)); 

    UINT nUnused = m_lpBufMax - m_lpBufCur; 

    ULONG nTotalNeeded = ((ULONG)nBytesNeeded) + nUnused; // 从文件中读取 

    if (!m_bDirectBuffer) 

    {  ASSERT(m_lpBufCur != NULL); 

     ASSERT(m_lpBufStart != NULL); 

     ASSERT(m_lpBufMax != NULL); 

     if (m_lpBufCur > m_lpBufStart)  

    {   //保留剩余的尚未处理的部分，将它们移动到头   

    if ((int)nUnused > 0)  

     {    memmove(m_lpBufStart, m_lpBufCur, nUnused); 

       m_lpBufCur = m_lpBufStart;    

    m_lpBufMax = m_lpBufStart + nUnused;  

     }   

    // read to satisfy nBytesNeeded or nLeft if possible  

     UINT nRead = nUnused;  

     UINT nLeft = m_nBufSize-nUnused;  

     UINT nBytes;   BYTE* lpTemp = m_lpBufStart + nUnused;   do   {    nBytes = m_pFile-> Read(lpTemp, nLeft);    lpTemp = lpTemp + nBytes;    nRead += nBytes;    nLeft -= nBytes;   }   while (nBytes > 0 && nLeft > 0 && nRead < nBytesNeeded);   m_lpBufCur = m_lpBufStart;   m_lpBufMax = m_lpBufStart + nRead;  } } else {  // 如果是针对内存区域(CMemFile),移动相关指针，指向新的一块内存  if (nUnused != 0)   m_pFile-> Seek(-(LONG)nUnused, CFile::current);  UINT nActual = m_pFile-> GetBufferPtr(CFile::bufferRead, m_nBufSize,   (void**)&m_lpBufStart, (void**)&m_lpBufMax);  ASSERT(nActual == (UINT)(m_lpBufMax - m_lpBufStart));  m_lpBufCur = m_lpBufStart; } // not enough data to fill request? if ((ULONG)(m_lpBufMax - m_lpBufCur) < nTotalNeeded)  AfxThrowArchiveException(CArchiveException::endOfFile);}

五.指定长度数据段落的读写

以下分析
UINT Read(void* lpBuf, UINT nMax); 读取长度为nMax的数据
void Write(const void* lpBuf, UINT nMax); 写入指定长度nMax的数据
对于大段数据的读写，先使用当前缓冲区中的内容或空间读取或写入，若这些空间够用了，则结束。
否则，从剩余的数据中找出最大的缓冲区整数倍大小的一块数据，直接读写到存储煤质(不反复使用缓冲区)。
剩余的余数部分，再使用缓冲区读写。
(说明:缓冲区读写的主要目的是将零散的数据以缓冲区大小为尺度来处理。对于大型数据，其中间的部分，不是零散的数据，使用缓冲区已经没有意思，故直接读写)

①读取

    UINT CArchive::Read(void* lpBuf, UINT nMax){ ASSERT_VALID(m_pFile); if (nMax == 0)  return 0; UINT nMaxTemp = nMax;  //还需要读入的长度，读入一部分，就减相应数值，直到此数值变为零  //处理当前缓冲区中剩余部分。 //如果要求读入字节小于缓冲区中剩余部分,则第一部分为要求读入的字节数， //否则读入全部剩余部分  UINT nTemp = min(nMaxTemp, (UINT)(m_lpBufMax - m_lpBufCur));    memcpy(lpBuf, m_lpBufCur, nTemp); m_lpBufCur += nTemp; lpBuf = (BYTE*)lpBuf + nTemp; //移动读出内容所在区域的指针 nMaxTemp -= nTemp; //当前缓冲区中剩余部分不够要求读入的长度。 //还有字节需要读，则需要根据需要执行若干次填充缓冲区，读出，直到读出指定字节。 if (nMaxTemp != 0)   {  //计算出去除尾数部分的字节大小(整数个缓冲区大小)   //对于这些部分，字节从文件对象中读出，放到输出缓冲区  nTemp = nMaxTemp - (nMaxTemp % m_nBufSize);    UINT nRead = 0;  UINT nLeft = nTemp;  UINT nBytes;  do  {   nBytes = m_pFile-> Read(lpBuf, nLeft); //要求读入此整数缓冲区部分大小   lpBuf = (BYTE*)lpBuf + nBytes;   nRead += nBytes;   nLeft -= nBytes;  }  while ((nBytes > 0) && (nLeft > 0)); 知道读入了预定大小，或到达文件尾  nMaxTemp -= nRead;  if (nRead == nTemp) //读入的字节等于读入的整数倍部分  该读最后的余数部分了  {   // 建立装有此最后余数部分的内容的CArchive的工作缓冲区。   if (!m_bDirectBuffer)   {    UINT nLeft = max(nMaxTemp, (UINT)m_nBufSize);    UINT nBytes;    BYTE* lpTemp = m_lpBufStart;    nRead = 0;    do    {     nBytes = m_pFile-> Read(lpTemp, nLeft);  //从文件中读入到CArchive缓冲区     lpTemp = lpTemp + nBytes;     nRead += nBytes;     nLeft -= nBytes;    }    while ((nBytes > 0) && (nLeft > 0) && nRead < nMaxTemp);    m_lpBufCur = m_lpBufStart;    m_lpBufMax = m_lpBufStart + nRead;   }   else   {    nRead = m_pFile-> GetBufferPtr(CFile::bufferRead, m_nBufSize,     (void**)&m_lpBufStart, (void**)&m_lpBufMax);    ASSERT(nRead == (UINT)(m_lpBufMax - m_lpBufStart));    m_lpBufCur = m_lpBufStart;   }   //读出此剩余部分到输出   nTemp = min(nMaxTemp, (UINT)(m_lpBufMax - m_lpBufCur));   memcpy(lpBuf, m_lpBufCur, nTemp);   m_lpBufCur += nTemp;   nMaxTemp -= nTemp;  }   } return nMax - nMaxTemp;}

②保存,写入

    void CArchive::Write(const void* lpBuf, UINT nMax){ if (nMax == 0)  return;  //读入可能的部分到缓冲区当前的剩余部分  UINT nTemp = min(nMax, (UINT)(m_lpBufMax - m_lpBufCur)); memcpy(m_lpBufCur, lpBuf, nTemp); m_lpBufCur += nTemp; lpBuf = (BYTE*)lpBuf + nTemp; nMax -= nTemp; if (nMax > 0)  //还有未写入的部分 {  Flush();    //将当前缓冲区写入到存储煤质  //计算出整数倍缓冲区大小的字节数  nTemp = nMax - (nMax % m_nBufSize);  m_pFile-> Write(lpBuf, nTemp);  //直接写到文件  lpBuf = (BYTE*)lpBuf + nTemp;  nMax -= nTemp;  //剩余部分添加到缓冲区  if (m_bDirectBuffer)  {   // sync up direct mode buffer to new file position   VERIFY(m_pFile-> GetBufferPtr(CFile::bufferWrite, m_nBufSize,    (void**)&m_lpBufStart, (void**)&m_lpBufMax) == (UINT)m_nBufSize);   ASSERT((UINT)m_nBufSize == (UINT)(m_lpBufMax - m_lpBufStart));   m_lpBufCur = m_lpBufStart;  }  // copy remaining to active buffer  ASSERT(nMax < (UINT)m_nBufSize);  ASSERT(m_lpBufCur == m_lpBufStart);  memcpy(m_lpBufCur, lpBuf, nMax);  m_lpBufCur += nMax; }}

六.字符串的读写

①CArchive提供的WriteString和ReadString

字符串写

    void CArchive::WriteString(LPCTSTR lpsz){ ASSERT(AfxIsValidString(lpsz)); Write(lpsz, lstrlen(lpsz) * sizeof(TCHAR));  //调用Write，将字符串对应的一段数据写入}

字符串读(读取一行字符串)

    LPTSTR CArchive::ReadString(LPTSTR lpsz, UINT nMax){ // if nMax is negative (such a large number doesn''t make sense given today''s // 2gb address space), then assume it to mean "keep the newline". int nStop = (int)nMax < 0 ? -(int)nMax : (int)nMax; ASSERT(AfxIsValidAddress(lpsz, (nStop+1) * sizeof(TCHAR))); _TUCHAR ch; int nRead = 0; TRY {  while (nRead < nStop)  {   *this >> ch;  //读出一个字节   // stop and end-of-line (trailing ''/n'' is ignored)  遇换行—回车   if (ch == ''/n'' || ch == ''/r'')   {    if (ch == ''/r'')     *this >> ch;    // store the newline when called with negative nMax    if ((int)nMax != nStop)     lpsz[nRead++] = ch;    break;   }   lpsz[nRead++] = ch;  } } CATCH(CArchiveException, e) {  if (e-> m_cause == CArchiveException::endOfFile)  {   DELETE_EXCEPTION(e);   if (nRead == 0)    return NULL;  }  else  {   THROW_LAST();  } } END_CATCH lpsz[nRead] = ''/0''; return lpsz;}

ReadString到CString对象,可以多行字符

    BOOL CArchive::ReadString(CString& rString){ rString = &afxChNil;    // empty string without deallocating const int nMaxSize = 128; LPTSTR lpsz = rString.GetBuffer(nMaxSize); LPTSTR lpszResult; int nLen; for (;;) {  lpszResult = ReadString(lpsz, (UINT)-nMaxSize); // store the newline  rString.ReleaseBuffer();  // if string is read completely or EOF  if (lpszResult == NULL ||   (nLen = lstrlen(lpsz)) < nMaxSize ||   lpsz[nLen-1] == ''/n'')  {   break;  }  nLen = rString.GetLength();  lpsz = rString.GetBuffer(nMaxSize + nLen) + nLen; } // remove ''/n'' from end of string if present lpsz = rString.GetBuffer(0); nLen = rString.GetLength(); if (nLen != 0 && lpsz[nLen-1] == ''/n'')  rString.GetBufferSetLength(nLen-1); return lpszResult != NULL;}

②使用CString对象的"<<"与">>"符读写字符串

CString定义了输入输出符,可以象基本类型的数据一样使用CArchive 的操作符定义

    friend CArchive& AFXAPI operator<<(CArchive& ar, const CString& string);friend CArchive& AFXAPI operator>>(CArchive& ar, CString& string);

    // CString serialization code// String format://      UNICODE strings are always prefixed by 0xff, 0xfffe//      if < 0xff chars: len:BYTE, TCHAR chars//      if >= 0xff characters: 0xff, len:WORD, TCHAR chars//      if >= 0xfffe characters: 0xff, 0xffff, len:DWORD, TCHARsCArchive& AFXAPI operator<<(CArchive& ar, const CString& string){ // special signature to recognize unicode strings#ifdef _UNICODE ar << (BYTE)0xff; ar << (WORD)0xfffe;#endif if (string.GetData()-> nDataLength < 255) {  ar << (BYTE)string.GetData()-> nDataLength; } else if (string.GetData()-> nDataLength < 0xfffe) {  ar << (BYTE)0xff;  ar << (WORD)string.GetData()-> nDataLength; } else {  ar << (BYTE)0xff;  ar << (WORD)0xffff;  ar << (DWORD)string.GetData()-> nDataLength; } ar.Write(string.m_pchData, string.GetData()-> nDataLength*sizeof(TCHAR)); return ar;}// return string length or -1 if UNICODE string is found in the archiveAFX_STATIC UINT AFXAPI _AfxReadStringLength(CArchive& ar){ DWORD nNewLen; // attempt BYTE length first BYTE bLen; ar >> bLen; if (bLen < 0xff)  return bLen; // attempt WORD length WORD wLen; ar >> wLen; if (wLen == 0xfffe) {  // UNICODE string prefix (length will follow)  return (UINT)-1; } else if (wLen == 0xffff) {  // read DWORD of length  ar >> nNewLen;  return (UINT)nNewLen; } else  return wLen;}CArchive& AFXAPI operator>>(CArchive& ar, CString& string){#ifdef _UNICODE int nConvert = 1;   // if we get ANSI, convert#else int nConvert = 0;   // if we get UNICODE, convert#endif UINT nNewLen = _AfxReadStringLength(ar); if (nNewLen == (UINT)-1) {  nConvert = 1 - nConvert;  nNewLen = _AfxReadStringLength(ar);  ASSERT(nNewLen != -1); } // set length of string to new length UINT nByteLen = nNewLen;#ifdef _UNICODE string.GetBufferSetLength((int)nNewLen); nByteLen += nByteLen * (1 - nConvert);  // bytes to read#else nByteLen += nByteLen * nConvert;    // bytes to read if (nNewLen == 0)  string.GetBufferSetLength(0); else  string.GetBufferSetLength((int)nByteLen+nConvert);#endif // read in the characters if (nNewLen != 0) {  ASSERT(nByteLen != 0);  // read new data  if (ar.Read(string.m_pchData, nByteLen) != nByteLen)   AfxThrowArchiveException(CArchiveException::endOfFile);  // convert the data if as necessary  if (nConvert != 0)  {#ifdef _UNICODE   CStringData* pOldData = string.GetData();   LPSTR lpsz = (LPSTR)string.m_pchData;#else   CStringData* pOldData = string.GetData();   LPWSTR lpsz = (LPWSTR)string.m_pchData;#endif   lpsz[nNewLen] = ''/0'';    // must be NUL terminated   string.Init();   // don''t delete the old data   string = lpsz;   // convert with operator=(LPWCSTR)   CString::FreeData(pOldData);  } } return ar;}

七.CObject派生对象的读写

MFC中多数类都从CObject类派生，CObject类与CArchive类有着良好的合作关系，能实现将对象序列化储存到文件或其他媒介中去，或者读取预先储存的对象，动态建立对象等功能。

①CObject定义了针对CArvhive的输入输出操作符,可以向其他基本数据类型一样使用"<<"、"<<"符号

    CArchive& AFXAPI operator<<(CArchive& ar, const CObject* pOb) { ar.WriteObject(pOb); return ar; }CArchive& AFXAPI operator>>(CArchive& ar, CObject*& pOb) { pOb = ar.ReadObject(NULL); return ar; }

当使用这些符号时，实际上执行的是CArchive的WriteObject和ReadObject成员

②WriteObject与ReadObject

在WriteObject与ReadObject中先写入或读取运行时类信息(CRuntimeClas)，再调用Serialze(..),按其中的代码读写具体的对象数据。

因此，只要在CObject派生类中重载Serilize()函数，写入具体的读写过程，就可以使对象具有存储与创建能力。

    //将对象写入到缓冲区void CArchive::WriteObject(const CObject* pOb){ DWORD nObIndex; // make sure m_pStoreMap is initialized MapObject(NULL); if (pOb == NULL) {  // save out null tag to represent NULL pointer  *this << wNullTag; } else if ((nObIndex = (DWORD)(*m_pStoreMap)[(void*)pOb]) != 0)  // assumes initialized to 0 map {  // save out index of already stored object  if (nObIndex < wBigObjectTag)   *this << (WORD)nObIndex;  else  {   *this << wBigObjectTag;   *this << nObIndex;  } } else {  // write class of object first  CRuntimeClass* pClassRef = pOb-> GetRuntimeClass();  WriteClass(pClassRef);  //写入运行类信息  // enter in stored object table, checking for overflow  CheckCount();  (*m_pStoreMap)[(void*)pOb] = (void*)m_nMapCount++;  // 调用CObject的Serialize成员，按其中的代码写入类中数据。  ((CObject*)pOb)-> Serialize(*this); }}

    CObject* CArchive::ReadObject(const CRuntimeClass* pClassRefRequested){ // attempt to load next stream as CRuntimeClass UINT nSchema; DWORD obTag; //先读入运行时类信息 CRuntimeClass* pClassRef = ReadClass(pClassRefRequested, &nSchema, &obTag); // check to see if tag to already loaded object CObject* pOb; if (pClassRef == NULL) {  if (obTag > (DWORD)m_pLoadArray-> GetUpperBound())  {   // tag is too large for the number of objects read so far   AfxThrowArchiveException(CArchiveException::badIndex,    m_strFileName);  }  pOb = (CObject*)m_pLoadArray-> GetAt(obTag);  if (pOb != NULL && pClassRefRequested != NULL &&    !pOb-> IsKindOf(pClassRefRequested))  {   // loaded an object but of the wrong class   AfxThrowArchiveException(CArchiveException::badClass,    m_strFileName);  } } else {  // 建立对象  pOb = pClassRef-> CreateObject();  if (pOb == NULL)   AfxThrowMemoryException();  // Add to mapping array BEFORE de-serializing  CheckCount();  m_pLoadArray-> InsertAt(m_nMapCount++, pOb);  // Serialize the object with the schema number set in the archive  UINT nSchemaSave = m_nObjectSchema;  m_nObjectSchema = nSchema;  pOb-> Serialize(*this); //调用CObject的Serialize,按其中代码读入对象数据。  m_nObjectSchema = nSchemaSave;  ASSERT_VALID(pOb); } return pOb;}

③运行时类信息的读写

为了避免众多重复的同类对象写入重复的类信息，CArchive中使用CMap对象储存和检索类信息。

    void CArchive::WriteClass(const CRuntimeClass* pClassRef){ ASSERT(pClassRef != NULL); ASSERT(IsStoring());    // proper direction if (pClassRef-> m_wSchema == 0xFFFF) {  TRACE1("Warning: Cannot call WriteClass/WriteObject for %hs./n",   pClassRef-> m_lpszClassName);  AfxThrowNotSupportedException(); } // make sure m_pStoreMap is initialized MapObject(NULL); // write out class id of pOb, with high bit set to indicate // new object follows // ASSUME: initialized to 0 map DWORD nClassIndex; if ((nClassIndex = (DWORD)(*m_pStoreMap)[(void*)pClassRef]) != 0) {  // previously seen class, write out the index tagged by high bit  if (nClassIndex < wBigObjectTag)   *this << (WORD)(wClassTag | nClassIndex);  else  {   *this << wBigObjectTag;   *this << (dwBigClassTag | nClassIndex);  } } else {  // store new class  *this << wNewClassTag;  pClassRef-> Store(*this);  // store new class reference in map, checking for overflow  CheckCount();  (*m_pStoreMap)[(void*)pClassRef] = (void*)m_nMapCount++; }}

    CRuntimeClass* CArchive::ReadClass(const CRuntimeClass* pClassRefRequested, UINT* pSchema, DWORD* pObTag){ ASSERT(pClassRefRequested == NULL ||  AfxIsValidAddress(pClassRefRequested, sizeof(CRuntimeClass), FALSE)); ASSERT(IsLoading());    // proper direction if (pClassRefRequested != NULL && pClassRefRequested-> m_wSchema == 0xFFFF) {  TRACE1("Warning: Cannot call ReadClass/ReadObject for %hs./n",   pClassRefRequested-> m_lpszClassName);  AfxThrowNotSupportedException(); } // make sure m_pLoadArray is initialized MapObject(NULL); // read object tag - if prefixed by wBigObjectTag then DWORD tag follows DWORD obTag; WORD wTag; *this >> wTag; if (wTag == wBigObjectTag)  *this >> obTag; else  obTag = ((wTag & wClassTag) << 16) | (wTag & ~wClassTag); // check for object tag (throw exception if expecting class tag) if (!(obTag & dwBigClassTag)) {  if (pObTag == NULL)   AfxThrowArchiveException(CArchiveException::badIndex, m_strFileName);  *pObTag = obTag;  return NULL; } CRuntimeClass* pClassRef; UINT nSchema; if (wTag == wNewClassTag) {  // new object follows a new class id  if ((pClassRef = CRuntimeClass::Load(*this, &nSchema)) == NULL)   AfxThrowArchiveException(CArchiveException::badClass, m_strFileName);  // check nSchema against the expected schema  if ((pClassRef-> m_wSchema & ~VERSIONABLE_SCHEMA) != nSchema)  {   if (!(pClassRef-> m_wSchema & VERSIONABLE_SCHEMA))   {    // schema doesn''t match and not marked as VERSIONABLE_SCHEMA    AfxThrowArchiveException(CArchiveException::badSchema,     m_strFileName);   }   else   {    // they differ -- store the schema for later retrieval    if (m_pSchemaMap == NULL)     m_pSchemaMap = new CMapPtrToPtr;    ASSERT_VALID(m_pSchemaMap);    m_pSchemaMap-> SetAt(pClassRef, (void*)nSchema);   }  }  CheckCount();  m_pLoadArray-> InsertAt(m_nMapCount++, pClassRef); } else {  // existing class index in obTag followed by new object  DWORD nClassIndex = (obTag & ~dwBigClassTag);  if (nClassIndex == 0 || nClassIndex > (DWORD)m_pLoadArray-> GetUpperBound())   AfxThrowArchiveException(CArchiveException::badIndex,    m_strFileName);  pClassRef = (CRuntimeClass*)m_pLoadArray-> GetAt(nClassIndex);  ASSERT(pClassRef != NULL);  // determine schema stored against objects of this type  void* pTemp;  BOOL bFound = FALSE;  nSchema = 0;  if (m_pSchemaMap != NULL)  {   bFound = m_pSchemaMap-> Lookup( pClassRef, pTemp );   if (bFound)    nSchema = (UINT)pTemp;  }  if (!bFound)   nSchema = pClassRef-> m_wSchema & ~VERSIONABLE_SCHEMA;   } // check for correct derivation if (pClassRefRequested != NULL &&  !pClassRef-> IsDerivedFrom(pClassRefRequested)) {  AfxThrowArchiveException(CArchiveException::badClass, m_strFileName); } // store nSchema for later examination if (pSchema != NULL)  *pSchema = nSchema; else  m_nObjectSchema = nSchema; // store obTag for later examination if (pObTag != NULL)  *pObTag = obTag; // return the resulting CRuntimeClass* return pClassRef;}

    八.MFC中Doc中Serialize方法执行过程

        可参考《深入浅出MFC》第八章

        当我们想保存文件的时候，点击SaveAs，这将会发出一个消息给我们的Document，然后调用它的OnFileSaveAs，在这个函数中会去调用它自己的DoSave函数，然后再去调用自己的OnSaveDocument函数。在OnSaveDocument函数在是很有意思的，首先它会新创建一个CFile的对象，然后将这个对象和一个新的CArchive对象相单关联，就是将这个CFile对象作为一个参数来创建我们的CArchive对象。然后将这个CArchive对象与这个窗体相关联，这在后面的调用的时候是有用的，到最后在这个函数中还要实现台面上的保存，调用这个CDocument对象的Serialize函数。