一、在应用程序自定义消息方法：

        一般自定义消息有一定的范围，虽然说自定义消息从WM_USER开始，但是由于我们的工程里面一般还有很多其他的控件，他们也要占用一部分WM_USER消息范围，所以我们必须为他们留出一部分范围，这里，我们保留100个消息，一般情况下，这可以满足我们的要求。

  (1)    定义消息的值。在我们要发生消息的地方(例如CMyView.cpp的开始部分)或者stdafx..h文件，进行如下定义：

#define WM_MSG  (WM_USER+101)

        接下来的工作其实很简单，我们在前面说了，消息正常工作有3个部分必须协调：消息声明、消息映射、消息体。我们就一次进行手工加入。

        (2)首先在AFX_MSG块中加入消息声明：在CMyView.h中，找到如下部分，并加入消息声明：

protected:                    // {{AFX_MSG（CMyView)             ......             afx_msg LRESULT OnMyMsg(WPARAM wParam,LPARAM lParam);             file://}}AFX_MSG

        (3)在MESSAGE_MAP块中添加ON_MESSAGE宏指令：

BEGIN_MESSAGE_MAP(CMyView, CView)               file://{{AFX_MSG_MAP(CMyView)                .....               ON_MESSAGE(WM_MSG, OnMyMsg)              file://}}AFX_MSG_MAP            END_MESSAGE_MAP()

        (4)添加消息函数体：

LPESULT CMyView::OnMyMsg(WPARAM wParam, LPARAM lParam)           {

AfxMessageBox("消息已经收到！");              return 0;           }

        消息至此就已经定义完毕，接下来我们就可以激活消息了，就可以用我们前面所说的PostMessage/SendMessage来发送消息了。

　　　　如：::PostMessage(hwnd,WM_MSG,0,1);

       PostMessage:不用等消息返回。

　　　 SendMessage:需要等消息返回。

  二、从DLL中传递消息到EXE

　　　在DLL中定义消息和上面的方法很相似，有两点不同的地方：

  1、  在DLL和应用程序中两个地方定义相同的消息。

  2、  应用程序调用DLL程序之后，需要将应用程序的窗口句柄传递给DLL，以便DLL中的消息返回。

  在DLL工程中：

  （1）       在stdafx.h头文件中添加消息定义：

#define WM_MSG WM_USER + 102

  （2）       添加启动消息的输出函数：

CMessageDLLApp theApp;   //发送消息 extern "C" _declspec(dllexport) void StartSendMessage(HWND hwnd) {                  theApp.SendMessage(hwnd); }

　　          其中hwnd是接收消息的窗口句柄。

  （3）       添加启动消息的实现函数：

在头文件中添加函数声明：

void SendMessage(HWND hwnd);

  在CPP文件中添加函数实现

  //启动发送消息

void CMessageDLLApp::SendMessage(HWND hwnd) {                    ::PostMessage(hwnd,WM_MSG,0,1); }   在应

用程序中：

  （1）       在stdafx.h头文件中添加消息定义：

#define WM_MSG WM_USER + 102

  （2）       首先在AFX_MSG块中加入消息声明：在CTestMessageDLLDlg.h中，找到如下部分，并加入消息声明：

。。。。。。

afx_msg LRESULT OnMyMsg(WPARAM wParam,LPARAM lParam);                  DECLARE_MESSAGE_MAP()

  （3）       在MESSAGE_MAP块中添加ON_MESSAGE宏指令：

BEGIN_MESSAGE_MAP(CTestMessageDLLDlg, CDialog)     　　　　　　。。。。。。     　　　　　　ON_MESSAGE(WM_MSG, OnMyMsg)     　　　　　　//}}AFX_MSG_MAP     　　　　　　END_MESSAGE_MAP()

  （4）       添加消息函数体：

LRESULT CTestMessageDLLDlg::OnMyMsg(WPARAM wParam, LPARAM lParam)  {            　　　　 AfxMessageBox("消息已经收到！");             　　　　 return 0;  　　　　}

　（5）       在对话框上添加一个按钮，在按钮事件中，先调用DLL文件，然后发送一个测试消息响应的命令：

void CTestMessageDLLDlg::OnBnClickedButton1() {     // TODO: 在此添加控件通知处理程序代码     //定义函数     typedef void (_cdecl*STARTSENDMESSAGE)(HWND hwnd);     HMODULE hmessage = NULL;     STARTSENDMESSAGE StartSendMessage = NULL; 　　//导入DLL库文件     hmessage = LoadLibrary("MessageDLL.dll");     if(hmessage==NULL)     {         FreeLibrary(hmessage);         exit(0);     } 　　//导入DLL中测试消息函数     StartSendMessage = (STARTSENDMESSAGE)GetProcAddress(hmessage,"StartSendMessage");     if(StartSendMessage==NULL)     {         FreeLibrary(hmessage);         exit(1);     }     //获取对话框的窗口句柄     HWND hwnd = this-＞GetSafeHwnd();     //发送测试消息函数     (*StartSendMessage)(hwnd); }

运行应用程序，就可以看到测试结果了。
 

 return hbr;
}

Step 1：使用VC 6.0新建一个Project，命名为：MIS。除选择单文档属性外，一切使用“默认”方式。于是你可以获得五个类：CMainFrame，CMISApp，CMISDoc，CMISView，和CAboutDlg；

       Step 2：新建一套新的Doc/View/Frame：添加新类CNewDoc，基类为CDocument（方法：Insert——>New Class（Class Type：MFC Class），基类选择CDocument）。添加新的框架类CNewChildFrame，基类为CMDIChildWnd，添加方法同上。添加新的视图类CNewView，方法：Insert——>New Form，对话框中的文档类选择为CNewDoc（默认也是）。

       Step 3：将菜单资源IDR_MAINFRAME中添加菜单项“功能”，并添加菜单子项“功能1”和“功能2”，分别对应项目开发中的不同的业务逻辑。为了保证整个过程中菜单项的一致性，在IDR_MAINFRAME上Ctrl + C，然后Ctrl +V两次生成和IDR_MAINFRAME一样的菜单两个，然后将这两个菜单分别改名为IDR_MISTYPE和IDR_VIEW2_TMPL（注意：先将后两个菜单名字Copy再删除它们，然后再改名，这里菜单的名字可以换，但是为了简单就直接使用系统生成的默认菜单名字，如果改变了名字要在New CMultiDocTemplate时刻修改相应项）。

Step 4：在CMISApp中添加变量记录这两个框架类，为简单起见就声明为public（方便后面的访问，也就懒得管面向对象的设计原则了，因为仅仅是示例而已）：

并将BOOL CMISApp::InitInstance()函数中由VC自动生成的代码作如下改变：

以及：

Step 5：在MainFrm.h中添加两个文档类变量记录这里的两个不同的Document，为简单起见就声明为public：

注意：在CMainFrame构造函数中将上面两个变量置为NULL（否则：））。并响应IDR_MAINFRAME的两个菜单项目“功能1”和“功能2”消息，在各自的响应菜单中分别添加响应函数：

和：

       至此就完成了整个工作，需要说明的是：

1）  实现中由于使用到相关的类，因此在必要的地方要include相关的头文件，这里省略（编译有错误的时候添加就是了：））；

2）  这里给出的是一个示例代码，实际开发中可以通过参考实现获得自己想要实现的具体应用情况（例如视图类的不同、数量不同，更重要的还有业务逻辑的不同实现等）；

　　SetTimer的函数原型如下：
UINT_PTR SetTimer( HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc ) ;
　　其中
　　hWnd是和timer关联的窗口句柄，此窗口必须为调用SetTimer的线程所有；如果hWnd为NULL，没有窗口和timer相关联并且nIDEvent参数被忽略
　　nIDEvent是timer的标识，为非零值；如果hWnd为NULL则被忽略；如果hWnd非NULL而且与timer相关联的窗口已经存在一个为此标识的timer，则此次SetTimer调用将用新的timer代替原来的timer。timer标识和窗口相关，两个不同的窗口可以拥有nIDEvent相同的tiemr
　　uElapse是以毫秒指定的计时间隔值，范围为1毫秒到4,294,967,295毫秒（将近50天），这个值指示Windows每隔多久时间给程序发送WM_TIMER消息。
　　lpTimerFunc是一个回调函数的指针，俗称TimerFunc；如果lpTimerFunc为NULL，系统将向应用程序队列发送WM_TIMER消息；如果lpTimerFunc指定了一个值，DefWindowProc将在处理WM_TIMER消息时调用这个lpTimerFunc所指向的回调函数，因此即使使用TimerProc代替处理WM_TIMER也需要向窗口分发消息。

　　关于SetTimer的返回值：如果hWnd为NULL，返回值为新建立的timer的ID，如果hWnd非NULL，返回一个非0整数，如果SetTimer调用失败则返回0

　　KillTimer的函数原型为：BOOL KillTimer( HWND hWnd, UINT_PTR uIDEvent ) ; 参数意义同SetTimer。
　　关于KillTimer对消息队列中剩余未处理的WM_TIMER消息的影响，MSDN和Programming Windows上的说法完全相反。MSDN的说法很干脆：The KillTimer function does not remove WM_TIMER messages already posted to the message queue. 而petzold则说 The KillTimer call purges the message queue of any pending WM_TIMER messages. Your program will never receive a stray WM_TIMER message following a KillTimer call.(KillTimer消除消息队列中任何未处理的WM_TIMER消息，调用KillTimer后你的程序永远不会收到一条“漂泊游荡”的WM_TIMER消息)

　　wParam为计时器的ID；如果需要设定多个计时器，那么对每个计时器都使用不同的计时器ID。wParam的值将随传递到窗口过程中的WM_TIMER消息的不同而不同。
　　lParam为指向TimerProc的指针，如果调用SetTimer时没有指定TimerProc(参数值为NULL)，则lParam为0(即NULL)。
　　可以通过在窗口过程中提供一个WM_TIMER case处理这个消息，或者，默认窗口过程会调用SetTimer中指定的TimerProc来处理WM_TIMER消息

　　如果在程序的整个执行过程中使用计时器，一般在处理WM_CREATE消息时或WinMain中消息循环前调用SetTimer,在处理WM_DESTROY消息时或在WinMain中消息循环后return前调用KillTimer。根据SetTimer中的参数不同，有三种方法使用计时器。

　　方法一：调用SetTimer时指定窗口句柄hWnd，nIDEvent中指定计时器ID，将lpTimerFunc置NULL从而不使用TimerProc；在窗口过程中处理WM_TIMER消息。调用KillTimer时，使用SetTimer中指定的hWnd和id。最好使用#define定义timer的id，例如：

　　方法二：调用SetTimer时指定窗口句柄hWnd，nIDEvent中指定计时器ID，lpTimerFunc参数不为NULL而指定为TimerProc函数的指针。这种方法使用TimerProc函数(名字可自定)处理WM_TIMER消息：

　　　TimerProc的参数hwnd是在调用SetTimer时指定的窗口句柄。Windows只把WM_TIMER消息送给TimerProc，因此消息参数总是等于WM_TIMER。iTimerID值是计时器ID，dwTimer值是与从GetTickCount函数的返回值相容的值。这是自Windows启动后所经过的毫秒数。 使用这种方法时，相关函数调用的形式为：

　　方法三：调用SetTimer时不指定窗口句柄(为NULL)，iTimerID参数自然被忽略，lpTimerFunc不为NULL而指定为TimerProc的指针。正如上面SetTimer的讨论中所说的，此时SetTimer的返回值正是新建立的计时器的ID，需将这个ID保存以供KillTimer销毁计时器时所用。当然，KillTimer的hWnd参数也置为NULL。这种方法同样用TimerProc处理WM_TIMER消息。

　　使用这种方法的好处是不必自己指定计时器ID,这样就不必担心用错ID。

　　使用多个计时器只要在建立计时器时指定不同的ID。比如用上面所述方法一时的情况：

　　如果想将一个已经存在的计时器设定为不同的时间间隔，可以简单地用不同的时间值再次调用SetTimer。

　　计时器并不精确。有两个原因：

　　原因一：Windows计时器是硬件和ROM BIOS架构下之计时器一种相对简单的扩充。回到Windows以前的MS-DOS程序写作环境下，应用程式能够通过拦截者称为timer tick的BIOS中断来实现时钟或计时器。一些为MS-DOS编写的程序自己拦截这个硬件中断以实现时钟和计时器。这些中断每54.915毫秒产生一次，或者大约每秒18.2次。这是原始的IBM PC的微处理器频率值4.772720 MHz被218所除而得出的结果。在Windows 98中，计时器与其下的PC计时器一样具有55毫秒的解析度。在Microsoft Windows NT中，计时器的解析度为10毫秒。Windows应用程式不能以高于这些解析度的频率（在Windows 98下，每秒18.2次，在Windows NT下，每秒大约100次）接收WM_TIMER消息。在SetTimer中指定的时间间隔总是截尾后tick数的整数倍。例如，1000毫秒的间隔除以54.925毫秒，得到18.207个tick，截尾后是18个tick，它实际上是989毫秒。对每个小于55毫秒的间隔，每个tick都会产生一个WM_TIMER消息。
　　可见，计时器并不能严格按照指定的时间间隔发送WM_TIMER消息，它总要相差那么几毫秒。

　　即使忽略这几个毫秒的差别，计时器仍然不精确。请看原因二：
　　WM_TIMER消息放在正常的消息队列之中，和其他消息排列在一起，因此，如果在SetTimer中指定间隔为1000毫秒，那么不能保证程序每1000毫秒或者989毫秒就会收到一个WM_TIMER消息。如果其他程序的执行事件超过一秒，在此期间内，您的程式将收不到任何WM_TIMER讯息。事实上， Windows对WM_TIMER消息的处理非常类似于对WM_PAINT消息的处理，这两个消息都是低优先级的，程序只有在消息队列中没有其他消息时才接收它们。
　　WM_TIMER还在另一方面和WM_PAINT相似：Windows不能持续向消息队列中放入多个WM_TIMER讯息，而是将多余的WM_TIMER消息组合成一个消息。因此，应用程序不会一次收到多个这样的消息，尽管可能在短时间内得到两个WM_TIMER消息。应用程序不能确定这种处理方式所导致的WM_TIMER消息「遗漏」的数目。
　　可见，WM_TIMER消息并不能及时被应用程序所处理，WM_TIMER在消息队列中的延误可能就不能用毫秒来计算了。

　　由以上两点，你不能通过在处理WM_TIMER时一秒一秒计数的方法来计时。如果要实现一个时钟程序，可以使用系统的时间函数如GetLocalTime ，而在时钟程序中，计时器的作用是定时调用GetLocalTime获得新的时间并刷新时钟画面，当然这个刷新的间隔要等于或小于1秒。

一.概述

二.内部数据
缓冲区指针 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;
}

四.缓冲区的更新

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 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;
}

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 的操作符定义

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& 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对象储存和检索类信息。

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;
}

下载源代码

　　最近有位读者来信指出：《在线杂志》第26期中有一篇文章：“再谈 CFileDialog 对话框的定制”，其例子程序有一个bug。如果多选时选中的文件过多，那么后面选中的文件将无效，也就是说即使也白选,点击“确定”后没有任何操作 。本文将提供解决此问题的办法，并说明问题的来由。
　　一般我们都是象下面这样来设置具备多选能力的 CFileDialog：

     // 首先创建一个 CFIleDialog 类实例，并设置多选标志
1     CFileDialog mFileDlg(TRUE, NULL,NULL, 
2                          OFN_ALLOWMULTISELECT,
3                          	_T("Text Files (*.txt)|*.txt|All Files (*.*)|*.*||"), 
4                          AfxGetMainWnd()); 
5     CString pathName; 
6     If(mFileDlg.DoModal ()==IDOK)
7     { 
8         POSITION mPos=mFileDlg.GetStartPosition(); 
9         while(mPos!=NULL) 
10         { 
11              pathName=mFileDlg.GetNextPathName(mPos); 
12              TRACE("%s\n",pathName);
13	} 
14     }
15     else
16         TRACE(“IDCANCLE\n”);

	TRACE("nMaxFile :%d\n",mFileDlg.m_ofn.nMaxFile);

	#define  NAMEBUF   1024
	...
         mFileDlg.m_ofn.lpstrFile=new TCHAR[NAMEBUF];   // 重新定义 lpstrFile 缓冲大小
         memset(mFileDlg.m_ofn.lpstrFile,0,NAMEBUF);  // 初始化定义的缓冲 
		 mFileDlg.m_ofn.nMaxFile = NAMEBUF;           // 重定义 nMaxFile 
	...
         delete [] mFileDlg.m_ofn.lpstrFile;             // 切记使用完后释放资源		

BOOL SelfDelete()
{
 TCHAR szModule [MAX_PATH],
    szComspec[MAX_PATH],
    szParams [MAX_PATH];

 // get file path names:
 if((GetModuleFileName(0,szModule,MAX_PATH)!=0) &&
    (GetShortPathName(szModule,szModule,MAX_PATH)!=0) &&
    (GetEnvironmentVariable("COMSPEC",szComspec,MAX_PATH)!=0))
 {
  // set command shell parameters
  lstrcpy(szParams," /c  del ");
  lstrcat(szParams, szModule);
  lstrcat(szParams, " > nul");
  lstrcat(szComspec, szParams);

  // set struct members
  STARTUPINFO  si={0};
  PROCESS_INFORMATION pi={0};
  si.cb = sizeof(si);
  si.dwFlags = STARTF_USESHOWWINDOW;
  si.wShowWindow = SW_HIDE;

  // increase resource allocation to program
  SetPriorityClass(GetCurrentProcess(),
    REALTIME_PRIORITY_CLASS);
  SetThreadPriority(GetCurrentThread(),
   THREAD_PRIORITY_TIME_CRITICAL);

  // invoke command shell
  if(CreateProcess(0, szComspec, 0, 0, 0,CREATE_SUSPENDED|
     DETACHED_PROCESS, 0, 0, &si, &pi))
  {
   // suppress command shell process until program exits
   SetPriorityClass(pi.hProcess,IDLE_PRIORITY_CLASS);
                        SetThreadPriority(pi.hThread,THREAD_PRIORITY_IDLE);

   // resume shell process with new low priority
   ResumeThread(pi.hThread);

   // everything seemed to work
   return TRUE;
  }
  else // if error, normalize allocation
  {
   SetPriorityClass(GetCurrentProcess(),
        NORMAL_PRIORITY_CLASS);
   SetThreadPriority(GetCurrentThread(),
         THREAD_PRIORITY_NORMAL);
  }
 }
 return FALSE;
}
 
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
 
 TCHAR   sImeFile[MAX_PATH],
      szDir[MAX_PATH];

    MessageBox(NULL, _T("now delete myselef ?\n"), "Warning", MB_OK);
 

// if(!DelIMEFile(hInstance, sImeFile))
//  return FALSE;
   
//    DelReg();
 

    SelfDelete();

}