通过一天的努力终于弄了个obj文件解析。
从中获得了不少知识。
第一:
'\n'与'\r'有什么区别。
在计算机还没有出现之前,有一种叫做电传打字机(Teletype Model 33)的玩意,每秒钟可以打10个字符。但是它有一个问题,就是打完一行换行的时候,要用去0.2秒,正好可以打两个字符。要是在这0.2秒里面,又有新的字符传过来,那么这个字符将丢失。于是,研制人员想了个办法解决这个问题,就是在每行后面加两个表示结束的字符。一个叫做“回车”,告诉打字机把打印头定位在左边界;另一个叫做“换行”,告诉打字机把纸向下移一行。这就是“换行”和“回车”的来历,从它们的英语名字上也可以看出一二。
后来,计算机发明了,这两个概念也就被般到了计算机上。那时,存储器很贵,一些科学家认为在每行结尾加两个字符太浪费了,加一个就可以。于是,就出现了分歧。
Unix系统里,每行结尾只有“<换行>”,即“\n”;Windows系统里面,每行结尾是“<换行><回车>”,即“\n\r”(而obj文件格式结尾时\r\n;不知道这里是不是说错了,但这对我的程序没有影响);Mac系统里,每行结尾是“<回车>”。一个直接后果是,Unix/Mac系统下的文件在Windows里打开的话,所有文字会变成一行;而Windows里的文件在Unix/Mac下打开的话,在每行的结尾可能会多出一个^M符号。c语言编程时(windows系统)\r 就是return 回到 本行 行首 这就会把这一行以前的输出 覆盖掉 如:
int main() { cout << "hahaha" << "\r" << "xixi" ; }
最后只显示 xixi 而 hahaha 被覆盖了 \n 是回车+换行 把光标 先移到 行首 然后换到下一行 也就是 下一行的行首拉 int main() { cout << "hahaha" << "\n" << "xixi" ; }
第二:
CString与char* 的转换
这是一种略微硬性的转换,有关“正确”的做法,人们在认识上还存在许多混乱,正确的使用方法有很多,但错误的使用方法可能与正确的使用方法一样多。
我们首先要了解 CString 是一种很特殊的 C++ 对象,它里面包含了三个值:一个指向某个数据缓冲区的指针、一个是该缓冲中有效的字符记数以及一个缓冲区长度。 有效字符数的大小可以是从0到该缓冲最大长度值减1之间的任何数(因为字符串结尾有一个NULL字符)。字符记数和缓冲区长度被巧妙隐藏。
除非你做一些特殊的操作,否则你不可能知道给CString对象分配的缓冲区的长度。这样,即使你获得了该0缓冲的地址,你也无法更改其中的内容,不能截短字符串,也 绝对没有办法加长它的内容,否则第一时间就会看到溢出。
LPCTSTR 操作符(或者更明确地说就是 TCHAR * 操作符)在 CString 类中被重载了,该操作符的定义是返回缓冲区的地址,因此,如果你需要一个指向 CString 的 字符串指针的话,可以这样做:
CString s("GrayCat");
LPCTSTR p = s;
它可以正确地运行。这是由C语言的强制类型转化规则实现的。当需要强制类型转化时,C++规测容许这种选择。比如,你可以将(浮点数)定义为将某个复数 (有一对浮点数)进行强制类型转换后只返回该复数的第一个浮点数(也就是其实部)。可以象下面这样:
Complex c(1.2f, 4.8f);
float realpart = c;
如果(float)操作符定义正确的话,那么实部的的值应该是1.2。
这种强制转化适合所有这种情况,例如,任何带有 LPCTSTR 类型参数的函数都会强制执行这种转换。 于是,你可能有这样一个函数(也许在某个你买来的DLL中):
BOOL DoSomethingCool(LPCTSTR s);
你象下面这样调用它:
CString file("c:\\myfiles\\coolstuff")
BOOL result = DoSomethingCool(file);
它能正确运行。因为 DoSomethingCool 函数已经说明了需要一个 LPCTSTR 类型的参数,因此 LPCTSTR 被应用于该参数,在 MFC 中就是返回的串地址。
如果你要格式化字符串怎么办呢?
CString graycat("GrayCat");
CString s;
s.Format("Mew! I love %s", graycat);
注意由于在可变参数列表中的值(在函数说明中是以“...”表示的)并没有隐含一个强制类型转换操作符。你会得到什么结果呢?
一个令人惊讶的结果,我们得到的实际结果串是:
"Mew! I love GrayCat"。
因为 MFC 的设计者们在设计 CString 数据类型时非常小心, CString 类型表达式求值后指向了字符串,所以这里看不到任何象 Format 或 sprintf 中的强制类型转换,你仍然可以得到正确的行为。描述 CString 的附加数据实际上在 CString 名义地址之后。
有一件事情你是不能做的,那就是修改字符串。比如,你可能会尝试用“,”代替“.”(不要做这样的,如果你在乎国际化问题,你应该使用十进制转换的 National Language Support 特性,),下面是个简单的例子:
CString v("1.00"); // 货币金额,两位小数
LPCTSTR p = v;
p[lstrlen(p) - 3] = '','';
这时编译器会报错,因为你赋值了一个常量串。如果你做如下尝试,编译器也会错:
strcat(p, "each");
因为 strcat 的第一个参数应该是 LPTSTR 类型的数据,而你却给了一个 LPCTSTR。
不要试图钻这个错误消息的牛角尖,这只会使你自己陷入麻烦!
原因是缓冲有一个计数,它是不可存取的(它位于 CString 地址之下的一个隐藏区域),如果你改变这个串,缓冲中的字符计数不会反映所做的修改。此外,如果字符串长度恰好是该字符串物理限制的长度(梢后还会讲到这个问题),那么扩展该字符串将改写缓冲以外的任何数据,那是你无权进行写操作的内存(不对吗?),你会毁换坏不属于你的内存。这是应用程序真正的死亡处方。
2. CString转化成char* 之二:使用 CString 对象的 GetBuffer 方法;
如果你需要修改 CString 中的内容,它有一个特殊的方法可以使用,那就是 GetBuffer,它的作用是返回一个可写的缓冲指针。 如果你只是打算修改字符或者截短字符串,你完全可以这样做:
CString s(_T("File.ext"));
LPTSTR p = s.GetBuffer();
LPTSTR dot = strchr(p, ''.''); // OK, should have used s.Find...
if(p != NULL)
*p = _T(''\0'');
s.ReleaseBuffer();
这是 GetBuffer 的第一种用法,也是最简单的一种,不用给它传递参数,它使用默认值 0,意思是:“给我这个字符串的指针,我保证不加长它”。当你调用 ReleaseBuffer 时,字符串的实际长度会被重新计算,然后存入 CString 对象中。
必须强调一点,在 GetBuffer 和 ReleaseBuffer 之间这个范围,一定不能使用你要操作的这个缓冲的 CString 对象的任何方法。因为 ReleaseBuffer 被调用之前,该 CString 对象的完整性得不到保障。研究以下代码:
CString s(...);
LPTSTR p = s.GetBuffer();
//... 这个指针 p 发生了很多事情
int n = s.GetLength(); // 很糟D!!!!! 有可能给出错误的答案!!!
s.TrimRight(); // 很糟!!!!! 不能保证能正常工作!!!!
s.ReleaseBuffer(); // 现在应该 OK
int m = s.GetLength(); // 这个结果可以保证是正确的。
s.TrimRight(); // 将正常工作。
假设你想增加字符串的长度,你首先要知道这个字符串可能会有多长,好比是声明字符串数组的时候用:
char buffer[1024];
表示 1024 个字符空间足以让你做任何想做得事情。在 CString 中与之意义相等的表示法:
LPTSTR p = s.GetBuffer(1024);
调用这个函数后,你不仅获得了字符串缓冲区的指针,而且同时还获得了长度至少为 1024 个字符的空间(注意,我说的是“字符”,而不是“字节”,因为 CString 是以隐含方式感知 Unicode 的)。
同时,还应该注意的是,如果你有一个常量串指针,这个串本身的值被存储在只读内存中,如果试图存储它,即使你已经调用了 GetBuffer ,并获得一个只读内存的指针,存入操作会失败,并报告存取错误。我没有在 CString 上证明这一点,但我看到过大把的 C 程序员经常犯这个错误。
C 程序员有一个通病是分配一个固定长度的缓冲,对它进行 sprintf 操作,然后将它赋值给一个 CString:
char buffer[256];
sprintf(buffer, "%......", args, ...); // ... 部分省略许多细节
CString s = buffer;
虽然更好的形式可以这么做:
CString s;
s.Format(_T("%...."), args, ...);
如果你的字符串长度万一超过 256 个字符的时候,不会破坏堆栈。
另外一个常见的错误是:既然固定大小的内存不工作,那么就采用动态分配字节,这种做法弊端更大:
int len = lstrlen(parm1) + 13 lstrlen(parm2) + 10 + 100;
char * buffer = new char[len];
sprintf(buffer, "%s is equal to %s, valid data", parm1, parm2);
CString s = buffer;
......
delete [] buffer;
它可以能被简单地写成:
CString s;
s.Format(_T("%s is equal to %s, valid data"), parm1, parm2);
需要注意 sprintf 例子都不是 Unicode 就绪的,尽管你可以使用 tsprintf 以及用 _T() 来包围格式化字符串,但是基本 思路仍然是在走弯路,这这样很容易出错。
3、CString 和临时对象
这是出现在 microsoft.public.vc.mfc 新闻组中的一个小问题,我简单的提一下,这个问题是有个程序员需要往注册表中写入一个字符串,他写道:
我试着用 RegSetValueEx() 设置一个注册表键的值,但是它的结果总是令我困惑。当我用char[]声明一个变量时它能正常工作,但是当我用 CString 的时候,总是得到一些垃圾:"ÝÝÝÝ...ÝÝÝÝÝÝ"为了确认是不是我的 CString 数据出了问题,我试着用 GetBuffer,然后强制转化成 char*,LPCSTR。GetBuffer 返回的值是正确的,但是当我把它赋值给 char* 时,它就变成垃圾了。以下是我的程序段:
char* szName = GetName().GetBuffer(20);
RegSetValueEx(hKey, "Name", 0, REG_SZ,
(CONST BYTE *) szName,
strlen (szName + 1));
这个 Name 字符串的长度小于 20,所以我不认为是 GetBuffer 的参数的问题。
真让人困惑,请帮帮我。
亲爱的 Frustrated,
你犯了一个相当微妙的错误,聪明反被聪明误,正确的代码应该象下面这样:
CString Name = GetName();
RegSetValueEx(hKey, _T("Name"), 0, REG_SZ,
(CONST BYTE *) (LPCTSTR)Name,
(Name.GetLength() + 1) * sizeof(TCHAR));
为什么我写的代码能行而你写的就有问题呢?主要是因为当你调用 GetName 时返回的 CString 对象是一个临时对象。参见:《C++ Reference manual》§12.2
在一些环境中,编译器有必要创建一个临时对象,这样引入临时对象是依赖于实现的。如果编译器引入的这个临时对象所属的类有构造函数的话,编译器要确保这个类的构造函数被调用。同样的,如果这个类声明有析构函数的话,也要保证这个临时对象的析构函数被调用。
编译器必须保证这个临时对象被销毁了。被销毁的确切地点依赖于实现.....这个析构函数必须在退出创建该临时对象的范围之前被调用。
大部分的编译器是这样设计的:在临时对象被创建的代码的下一个执行步骤处隐含调用这个临时对象的析构函数,实现起来,一般都是在下一个分号处。因此,这个 CString 对象在 GetBuffer 调用之后就被析构了(顺便提一句,你没有理由给 GetBuffer 函数传递一个参数,而且没有使用ReleaseBuffer 也是不对的)。所以 GetBuffer 本来返回的是指向这个临时对象中字符串的地址的指针,但是当这个临时对象被析构后,这块内存就被释放了。然后 MFC 的调试内存分配器会重新为这块内存全部填上 0xDD,显示出来刚好就是“Ý”符号。在这个时候你向注册表中写数据,字符串的内容当然全被破坏了。
我们不应该立即把这个临时对象转化成 char* 类型,应该先把它保存到一个 CString 对象中,这意味着把临时对象复制了一份,所以当临时的 CString 对象被析构了之后,这个 CString 对象中的值依然保存着。这个时候再向注册表中写数据就没有问题了。
此外,我的代码是具有 Unicode 意识的。那个操作注册表的函数需要一个字节大小,使用lstrlen(Name+1) 得到的实际结果对于 Unicode 字符来说比 ANSI 字符要小一半,而且它也不能从这个字符串的第二个字符起开始计算,也许你的本意是 lstrlen(Name) + 1(OK,我承认,我也犯了同样的错误!)。不论如何,在 Unicode 模式下,所有的字符都是2个字节大小,我们需要处理这个问题。微软的文档令人惊讶地对此保持缄默:REG_SZ 的值究竟是以字节计算还是以字符计算呢?我们假设它指的是以字节为单位计算,你需要对你的代码做一些修改来计算这个字符串所含有的字节大小。
第三:
Archive读取文件http://www.vckbase.com/document/viewdoc/?id=607
FMD开发文集 -- CArchive原理
作者:冯明德
MFC 提供CArchive类实现数据的缓冲区读写,同时定义了类对象的存储与读取方案。 以下对CArchvie 的内部实现作分析。
1.概述
2.内部数据
3.基本数据读写
4.缓冲区的更新
5.指定长度数据段落的读写
6.字符串的读写
7.CObject派生对象的读写
当建立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();
缓冲区将提取空,会调用FillBuffer。 nBytesNeeded为当前剩余部分上尚有用的字节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; //指向缓冲区首 } }
五.指定长度数据段落的读写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,将字符串对应的一段数据写入 }
ReadString到CString对象,可以多行字符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; }
②使用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定义了输入输出符,可以象基本类型的数据一样使用CArchive 的操作符定义
七.CObject派生对象的读写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, TCHARs CArchive& 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 archive AFX_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; }
MFC中多数类都从CObject类派生,CObject类与CArchive类有着良好的合作关系,能实现将对象序列化储存到文件或其他媒介中去,或者读取预先储存的对象,动态建立对象等功能。
①CObject定义了针对CArvhive的输入输出操作符,可以向其他基本数据类型一样使用"<<"、"<<"符号
当使用这些符号时,实际上执行的是CArchive的WriteObject和ReadObject成员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; }
②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对象储存和检索类信息。
在这里需要注意:1、有没有声明宏 _UNICODE,因为windows默认情况为unicode,而obj文件是以ascii码存储的,所以必须进行转换,不能直接从文件中读取;2、CArchive类的读取,有两种方法,一是使用流输入符>>读取(考虑到难以控制没有使用,但它可以在读取的时候实现转换),二是使用CArchive类的readstring方法(采用这个是因为即可以读取一行又可以全部存于CString中)我采用了把文件全部存于CString中,原因是读取一行的需要参数LPTSTR,而又声明有宏_UNICODE,所以实际上是LPWSTR,而obj文件是ASCII码,从而根本没有办法判断回车与换行符。而把文件全部存于CString中,则可以得到指向缓冲区的指针(CString::GetBuffer() 与 CString::ReleaseBuffer() ),然后强制转换为char*,即可当做字符串来操作。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; }
第四:CString的使用
虽然使用的不多,但是也要贴上,以备不时之需。http://baike.baidu.com/view/998109.htm#8
第五:使用了document-view结构
第六:不足之处
没有纹理,材质,光照,原因是自己还不熟悉。