2. 程式人生 > >MFC訊息對映原理

MFC訊息對映原理

阿新 • • 發佈：2018-12-15

模仿MFC的訊息對映原理

本文要求對C++語法比較熟悉(特別是虛擬函式的使用)，若不熟悉建議參閱《C++語法詳解》一書，電子工業出版社出版 1、訊息對映：就是把指定的訊息交給指定的函式進行處理的方法，這樣就形成了一個<訊息，處理函式>對。 2、本文有時會使用<M,F>表示<訊息，處理函式>對。 一、共用體(union)的使用 1、共用體可以實現以下兩個功能(詳見示例說明)。 1)、呼叫函式時不需要知道函式的名稱(通過函式指標呼叫)，以及確定呼叫該函式時需要傳遞什麼型別的形參(即可以確定函式原型)。 2)、在類繼承體系中實現類似虛擬函式的功能。 2、語法問題(指向類成員的指標)：使用指向類成員的函式指標時，必須通過類的物件或指向類的指標間接使用，比如class A{public:void f(){}}; A m; A *pa=&m; void (A::*pf)()=&A::f; 則應這樣通過pf呼叫f，即(ma.*pf)()或(pa->*pf)();是正確的，但不能直接使用pf呼叫成員函式f，即(*pf)();或(A::*pf)();錯誤。 示例3.5：共用體的使用(以下示例為C++程式)

#include "stdafx.h"  //對於C++程式，VC++編譯器必須包含此標頭檔案。
#include<iostream>
using namespace std;
class B;
typedef void (B::*PF)();  
class B{public:void f2(int,int){cout<<"FB"<<endl;}  };
class C:public B{public:void f3(int){cout<<"FC"<<endl;} };
class D:public C{public:void f4(int,int){cout<<"FD"<<endl;}
static PF pf;	static PF pf1; };
PF D::pf=(PF)&f3;  
PF D::pf1=(PF)&f4;/*定義靜態成員，此時pf指向C::f3的地址，pf1指向D::f4的地址。*/
union UN{PF uf;    //uf用於儲存類D中pf和pf1的地址。
void (B::*pf_0)(int,int);  /*通過共用體的成員pf_0呼叫相關的函式時，該函式必須具有void 
(B*::)(int,int)形式的原型。*/
void (B::*pf_1)(int);};   /*因為UN是共用體，因此其成員uf，pf_0，pf_1擁有相同的值，即他們都是指向同一地址的指標，但是三個函式指標的型別不一樣(即指向的函式的形參和返回型別不一樣)。*/
void main()
{	B *pb;	C mc;	D md;
	pb=&md;		UN meff;
//以下步驟可通過傳遞給meff.uf的函式的形參的不同，而選擇呼叫meff中的不同成員函式。
meff.uf=D::pf1;        /*meff.uf=D::pf1=(PF)&f4;可見，此時uf指向的是D::f4函式的地址*/
(pb->*meff.pf_0)(1,2);  /*輸出FD，因為meff是共用體物件，因此meff.uf，meff.pf_0，meff.pf_1是指向的相同地址的指標，即都指向的是uf所指向的D::f4函式的地址。 但是meff.pf_0的型別為void (B*::)(int,int)，而meff.pf_0的型別為void (B*::)(int)，因此(pb->*meff.pf_0)(1,2)該語句是在呼叫地址為D::f4處的函式，也就是呼叫類D中的函式f4，這就實現了通過父類的指標，間接的呼叫子類D中的成員函式f4，從而間接實現了虛擬函式的功能。此處應注意使用指向類成員函式的指標呼叫成員函式的語法。*/
//(pb->*meff.pf_0)(1,2);  //錯誤，實參太少，因為meff.pf_0的型別為void (B*::pf_0)(int,int)
	meff.uf=D::pf;        //此時uf指向C::f3，其原理同上
	(pb->*meff.pf_1)(1);}  //輸出FC，其原理同上。

二、處理單個<訊息，處理函式>對的訊息對映原理 示例3.6：簡單的訊息對映原理(本示例只能處理單個的<訊息,處理函式>對，以下程式為MFC程式)

本示例需要明白C++語法原理：指標與型別的關係
#include <afxwin.h>   
class A:public CWinApp{public:   BOOL InitInstance(); }; 
class B:public CFrameWnd{public:  B(){Create(NULL,_T("HYONG"),WS_OVERLAPPEDWINDOW);}};  

//❷、使用結構體型別建立<訊息，處理函式>對。
typedef void (*PF)();
struct S{UINT msg;UINT msgid; PF pf;};
LRESULT f1(WPARAM w, LPARAM l){::MessageBox(0,"C","D",0);return 0;} //用於處理訊息的函式
LRESULT f(WPARAM w, LPARAM l){ ::MessageBox(0,"A","B",0);return 0;} //用於處理訊息的函式
//❸、使用結構體型別的陣列關聯不同的<訊息，處理函式>對。以下程式碼可使用巨集進行封裝(包裝)
/*以下每個一個數組元素都指定了一個<M,F>對，比如ss[0]代表一對<M,F>，ss[1]又表示一對<M,F>，程式設計師只需把需要處理的<訊息，處理函式>對新增到以下陣列中即可實現訊息對映原理(即把指定的訊息使用指定的函式進行處理)，也就是說陣列ss中的資料，是由程式設計師指定的。*/
const S ss[]={{WM_LBUTTONDOWN,1,PF(f1)},{WM_RBUTTONDOWN,2,PF(f)}, {0,0,(PF)0}}; //重點陣列

/*❹、使用共用體間接呼叫訊息處理函式。以下共用體用於講解目的，只列出了一部分訊息處理函式可能出現的原型。MFC原始碼的內容是很長的。*/
union UN{PF pf; LRESULT (*pf_0)(WPARAM,LPARAM);LRESULT (*pf_1)(WPARAM,LPARAM);};
UN meff;  

LRESULT CALLBACK g(HWND h1,int msg, WPARAM w, LPARAM l){  //自定義的過程函式。
	switch (msg) {
		case WM_LBUTTONDOWN:
{meff.pf=ss[0].pf;  //初始化共用體變數meff，此時ss[0].pf指向的函式是f1。
meff.pf_1(w,l); /*❹、使用共用體間接呼叫訊息處理函式f1。程式設計師可能認為可以在此處直接呼叫訊息處理函式f1不就行了嗎？何必這麼麻煩？但是在MFC原始碼中，這部分內容是對程式設計師隱藏的，原始碼並不知道程式設計師向陣列ss中新增的“<訊息，處理函式>對”中的處理函式的名稱是什麼，因此不可能直接對“<訊息，處理函式>對”中的處理函式進行呼叫，而只能使用共用體的形式進行間接呼叫。*/
break;}
		case WM_RBUTTONDOWN:
			{meff.pf=ss[1].pf; //使共用體變數meff.pf指向ss[1].pf指向的函式是f。
				meff.pf_0(w,l); //呼叫f函式，處理滑鼠右鍵訊息
				break;}
		case WM_DESTROY: {	::PostQuitMessage(0);	break; }
		default:return ::DefWindowProc(h1, msg, w, l);	}
	return 0;	}
BOOL A::InitInstance(){   m_pMainWnd=new B();  
m_pMainWnd->ShowWindow(m_nCmdShow);	m_pMainWnd->UpdateWindow();
		//❶、重新設定MFC的過程函式為自定義的函式。
		SetWindowLongPtr(m_pMainWnd->m_hWnd,GWLP_WNDPROC,(LONG)g);  //重置過程函式為函式g。
		return TRUE;}
A ma;

按下滑鼠左鍵後彈出的訊息框如下圖(省略主視窗)： 在這裡插入圖片描述 程式演算法步驟詳解： 1、使用SetWindowLongPtr函式重新設定MFC程式的過程函式。 2、把需要處理的<訊息，處理函式>對(即<M,F>)，抽像為一個型別，假設使用結構體型別S進行表示，那麼每個結構體型別變數都會儲存有一個相對應的<M,F>。比如： typedef void (*PF)(); struct S{UINT msg;UINT msgid; PF pf;}; 1)、msg表示需要處理的訊息。 2)、msgid用於標示該結構體變數的一個id符號。該成員在本例無用處，但在後面會有用。 3)、pf表示用於處理訊息msg的處理函式。 4)、為什麼pf的型別是PF：因為訊息處理函式的原型並不是全部一致的，在進行訊息對映時應使用相同的函式原型形式(即PF的形式)以便對訊息處理函式進行統一管理，因此在使用訊息處理函式初始化該成員時需要把訊息處理函式強制轉換為PF型別。 3、建立一個結構體型別S的陣列用於儲存不同的<M,F>對，該陣列就是程式設計師把訊息指定給自定義函式進行處理的地方。比如： LRESULT f1(WPARAM w, LPARAM l){return 0;} //處理訊息的函式f1 LRESULT f(WPARAM w, LPARAM l){return 0;} //處理訊息的函式f const S ss[]={{WM_LBUTTONDOWN,1,PF(f1)},{WM_RBUTTONDOWN,2,PF(f)}, {0,0,(PF)0}}; 1)、陣列ss儲存有兩個<M,F>對，即處理滑鼠左鍵按下訊息的<WM_LBUTTONDOWN，f1>和處理滑鼠右鍵按下訊息的<WM_RBUTTONDOWN，f>。 2)、若程式設計師需要把其他訊息使用另外的函式進行處理，則只需把相應的<訊息，處理函式>對，新增到陣列ss中即可，這樣就實現了訊息的對映。 3)、完成以上步驟之後，則在過程函式中接收到需要處理的訊息時，只需呼叫“<M,F>”中的處理函式F處理該訊息即可。問題的關鍵是怎樣呼叫“處理函式F”。 4、使用共用體間接呼叫訊息處理函式： 怎樣呼叫相關聯的訊息處理函式：因為MFC的原始碼實現的訊息對映是向程式設計師隱藏了的，那麼在呼叫訊息處理函式時，MFC原始碼肯定是不知道程式設計師自定義的“訊息處理函式”的名稱的，這就意味著，不能在原始碼中直接呼叫訊息處理函式，而只能間接的呼叫類似以上陣列ss中的結構體S中的成員pf，即只能這樣呼叫訊息處理函式ss[1].pf();但因為pf的原型與訊息處理函式的原型並不相同(本例pf與f原型就不一致)，這就可能會產生錯誤，為了解決函式原型的問題，可以使用共用體型別的成員儲存訊息處理函式的原型，然後使用共用體成員間接呼叫訊息處理函式。比如：

union UN{PF pf; LRESULT (*pf_0)(WPARAM,LPARAM);LRESULT (*pf_1)(WPARAM,LPARAM);};
   UN meff;  
meff.pf=ss[0].pf;  //初始化共用體變數meff，其中ss[0].pf指向的函式是f1。
meff.pf_0(w,l);   //通過共用體成員pf_0間接呼叫訊息處理函式f1。

1)、以上共用體是用於講解目的，只列出了一部分訊息處理函式可能出現的原型。MFC原始碼的內容是很長的(因為包括了所有可能的訊息處理函式的原型)。 2)、注意共用體的特點，成員pf與pf_0和pf_1是共用的同一記憶體段，因此訪問共用體變數中的任一成員(比如pf、pf_0、pf_1)，他們的值都是一樣的。但除pf之外的其他成員儲存了“訊息處理函式”可能出現的各種原型，這就解決了訊息處理函式原型不一致的問題。 3)、共用體中的第一個成員pf主要是用於進入(或關聯)結構體S而使用的，或者說用於初始化共用體成員變數的，否則會因為型別不相同而無法初始化。比如UN meff; meff.pf=ss[0].pf; 此時便可在UN中尋找與ss[0].pf相對應的訊息處理函式原型相同的成員呼叫訊息處理函式，在本例中ss[0].pf指向的訊息處理函式是f1，在UN中與f1原型相同的成員是pf_0和pf_1，因此可使用其中任意一個間接的呼叫訊息處理函式f1，即可以這樣呼叫meff.pf_0(w,l); 其中w和l是假設的兩個正確的實參。

三、實現處理多個<訊息，處理函式>對的訊息對映原理 程式演算法如下： 在這裡插入圖片描述 示例3.7：處理多個訊息的訊息對映原理 注：以下示例需要結合上一示例進行閱讀

#include <afxwin.h>   //編寫MFC程式，必須包含此標頭檔案
class A:public CWinApp{public:   BOOL InitInstance(); }; 
class B:public CFrameWnd{public:  B(){Create(NULL,_T("HYONG"),WS_OVERLAPPEDWINDOW);}};  
//以下程式碼見示例3.6
LRESULT f1(WPARAM w, LPARAM l){::MessageBox(0,"C","D",0);return 0;} 
LRESULT f(WPARAM w, LPARAM l){ ::MessageBox(0,"A","B",0);return 0;} 
typedef void (*PF)();
struct S{UINT msg;UINT msgid; PF pf;};
const S ss[]={{WM_LBUTTONDOWN,1,PF(f1)},{WM_RBUTTONDOWN,2,PF(f)}, {0,0,(PF)0}};
union UN{PF pf; LRESULT (*pf_0)(WPARAM,LPARAM);LRESULT (*pf_1)(WPARAM,LPARAM);};

LRESULT CALLBACK g(HWND h1,int msg, WPARAM w, LPARAM l){ 
const S *s1=&ss[0];		const S *s2=0;		UN meff;
	//❶重點迴圈體：迴圈處理陣列ss中的<訊息，處理函式>對。
while(s1->msgid!=0){  //❷若末達到陣列ss的末尾則迴圈。
if(s1->msg==msg)  /*❸判斷捕獲到的訊息是否與程式設計師新增到陣列ss中“<訊息，處理函式>對”中的訊息相等，若相等，則說明該訊息需要呼叫陣列ss中的處理函式進行處理。*/
			{s2=s1;//❹s1用於迴圈處理陣列ss，不用於呼叫訊息處理函式，s2用來呼叫訊息處理函式。
			meff.pf=s2->pf;   //通過共用體呼叫與s1->msg相對應的訊息處理函式(原理見例3.6)。
switch(s2->msgid)  /*❺根據結構體S中的成員msgid的值，判斷使用共用體UN中的哪一個成員呼叫訊息處理函式，在MFC原始碼中，msgid是使用一個比較龐大的列舉來設定其與共用體UN相關聯的值的，本例為簡化原理，使用一個任意值。*/
{case 1:{(*meff.pf_0)(w,l);return 0;} /*此處的原理見示例3.6，此處必須使用retun跳出函式。*/
			case 2:{(*meff.pf_1)(w,l);return 0;}
case 3:return 0;   /*❻呼叫其他的訊息處理函式處理訊息的程式碼，在MFC原始碼中，該swtich結構是很龐大的，因為他包含了所有可能的訊息處理函式的原型的呼叫，本示例是一個簡化示例*/
			case 4:return 0;}	}  //if結束
		s1++;  //❼接著處理陣列ss中的下一個<訊息，處理函式>對。
			} //while迴圈結束。
if(s2==0);/*❽此處表示，若s2為空(即表示ss中沒有相關聯的<訊息，處理函式>對，或ss已達到末尾)，則什麼也不做。*/
/*以下為處理其他訊息的情形，在MFC原始碼中是使用CWnd類的成員函式DefWindowProc(注意，並非全域性的DefWindowProc)進行處理的。*/
switch (msg) {
		case WM_DESTROY: {	::PostQuitMessage(0);	break; }
		default:return ::DefWindowProc(h1, msg, w, l);	}	return 0;}  //函式g結束
BOOL A::InitInstance(){		m_pMainWnd=new B();  
		m_pMainWnd->ShowWindow(m_nCmdShow);	m_pMainWnd->UpdateWindow();
		HWND hh1=FindWindow(0,"HYONG"); 		SetWindowLong(hh1,GWLP_WNDPROC,(LONG)g); 
		return TRUE;}
A ma;

程式執行結果如下： 在這裡插入圖片描述

四、使用巨集封裝(包裝)之後的訊息對映原理

示例3.8：使用巨集封裝之後的訊息對映原理 注：以下示例需要結合上面兩個示例進行閱讀

#include <afxwin.h>   //編寫MFC程式，必須包含此標頭檔案
//❶、使用四個巨集DE，BEGIN，END，ON封裝訊息對映的程式碼。這些巨集在原始碼中是被封裝於另一個檔案中的
typedef void (*PF)();
struct S{UINT msg;UINT msgid; PF pf;};
#define DE() const S ss[]  //本示例使用DE代替原始碼中的DECLARE_MESSAGE_MAP巨集。
#define BEGIN() ={         
#define END() {0,0,(PF)0}};
#define ON(msg,pfn) {msg,1,PF(pfn)},  /*原始碼中S的成員msgid的值對於每一個ON_XXX都有一個特定的值。本示例為說明原理，簡化為值1。*/
union UN{PF pf; LRESULT (*pf_0)(WPARAM,LPARAM);LRESULT (*pf_1)(WPARAM,LPARAM);};

class A:public CWinApp{public:   BOOL InitInstance(); }; 
class B:public CFrameWnd{public:  B(){Create(NULL,_T("HYONG"),WS_OVERLAPPEDWINDOW);}};  

LRESULT f1(WPARAM w, LPARAM l){::MessageBox(0,"C","D",0);return 0;} 
LRESULT f(WPARAM w, LPARAM l){ ::MessageBox(0,"A","B",0);return 0;} 
//❷、在程式中使用巨集
DE()   //原始碼該語句是位於類之中的，即把陣列ss宣告為類的成員，本示例暫不考慮類成員的情形。
BEGIN()
ON(WM_LBUTTONDOWN,f)  //新增<訊息，處理函式>對，實現訊息對映。
ON(WM_RBUTTONDOWN,f1)
END()
//以上巨集展開後的原始碼如下：
//const S ss[]={ {WM_LBUTTONDOWN,1,PF(f)},{WM_RBUTTONDOWN,1,PF(f1)},{0,0,(PF)0}};
LRESULT CALLBACK g(HWND h1,int msg, WPARAM w, LPARAM l){ 
	const S *s1=&ss[0];		const S *s2=0;
	UN meff;
	//迴圈處理陣列ss中的<訊息，處理函式>對，見示例3.7的分析。
	while(s1->msgid!=0){  
		if(s1->msg==msg) {s2=s1;	  	meff.pf=s2->pf;	
switch(s2->msgid) 
				{case 1:{(*meff.pf_0)(w,l);return 0;} 
				case 2:{(*meff.pf_1)(w,l);return 0;}
				case 3:return 0; 
case 4:return 0;} }  //if結束
s1++;}//while迴圈結束。
	if(s2==0) ;
switch (msg) {
	case WM_DESTROY: {	PostQuitMessage(0);	break; }
	default:return ::DefWindowProc(h1, msg, w, l);	}	return 0;} //函式g結束
BOOL A::InitInstance(){   	m_pMainWnd=new B();  
		m_pMainWnd->ShowWindow(m_nCmdShow);	m_pMainWnd->UpdateWindow();
		HWND hh1=FindWindow(0,"HYONG"); 	SetWindowLong(hh1,GWLP_WNDPROC,(LONG)g); 
return TRUE;}
A ma;

執行結果與示例3.7類似。

五、完整的模仿MFC原始碼的訊息對映原理(請結合以上三個示例理解) 1、原始碼的訊息對映原理，是把儲存“<訊息，處理函式>對”的陣列宣告為類的成員的，本示例就是按這種方式來模仿訊息對映的。 2、注意：本模仿示例程式編譯器會產生大量的警告訊息，本示例主要是為了講解其原理，因此對程式儘量簡化，其中的警告訊息不影響原理的執行，讀者也可把其原理轉換為C++程式進行驗證(下一小節的訊息路由就是轉換為C++語言的示例)。 示例3.9：完整的模仿MFC原始碼的訊息對映原理

#include <afxwin.h>   
/*❶、使用四個巨集DE，BEGIN，END，ON封裝訊息對映的程式碼，本示例使用了繼承和類的機制。以下巨集在原始碼中是被封裝於另一個檔案中的*/
typedef void (CCmdTarget::*PF)();
typedef LRESULT (CWnd::*PF1)(WPARAM, LPARAM);
struct S{UINT msg;UINT msgid; PF pf;};/*原始碼中S的成員msgid的值對於每一個ON_XXX都有一個特定的值。本示例為說明原理，簡化為值1。*/
#define DE() static const S ss[];  //本示例使用DE代替原始碼中的DECLARE_MESSAGE_MAP巨集。
#define BEGIN(cl) const S cl::ss[]={         
#define END() {0,0,(PF)0}};
#define ON(msg,pfn) {msg,1,(PF)(LRESULT (CWnd::*)(WPARAM, LPARAM))(&pfn)},  
//❷、以下UN共用體中的成員都是指向類成員函式的指標，在使用他們時應注意C++的語法問題。
union UN{PF pf; LRESULT (CWnd::*pf_0)(WPARAM,LPARAM);LRESULT (CWnd::*pf_1)(WPARAM,LPARAM);};

class A:public CWinApp{public:   BOOL InitInstance(); }; 
class B:public CFrameWnd{public:  B(){Create(NULL,_T("HYONG"),WS_OVERLAPPEDWINDOW);}
LRESULT f1(WPARAM w, LPARAM l){::MessageBox(0,"C","D",0);return 0;} 
LRESULT f(WPARAM w, LPARAM l){ ::MessageBox(0,"A","B",0);return 0;} 
LRESULT CALLBACK g(HWND h1,int msg, WPARAM w, LPARAM l);
DE() //❸、在類之中使用巨集。展開後的程式碼為：static const S ss[];
};  
//❹、在類之外使用巨集。
BEGIN(B)
ON(WM_LBUTTONDOWN,f)  //新增<訊息，處理函式>對，實現訊息對映。
ON(WM_RBUTTONDOWN,f1) 
END()
//以上巨集展開後的程式碼如下：由程式碼可見，就是給陣列成員ss賦值。
/*const S B::ss[]={ {WM_LBUTTONDOWN,1,(PF)(LRESULT (CWnd::*)(WPARAM, LPARAM))(&f)}, {WM_RBUTTONDOWN,1,(PF)(LRESULT (CWnd::*)(WPARAM, LPARAM))(&f1)}, {0,0,(PF)0}};*/

LRESULT CALLBACK gg(HWND h1,int msg, WPARAM w, LPARAM l) //過程函式
{B mb; return mb.g(h1,msg,w,l);}  /*❺、關鍵重點：把過程函式的具體處理交給類B的成員函式g進行處理，MFC原始碼使用的是類似的迂迴的處理訊息的機制。*/
LRESULT CALLBACK B::g(HWND h1,int msg, WPARAM w, LPARAM l){ 
	const S *s1=&B::ss[0];
	const S *s2=0;
	UN meff;
	//迴圈處理陣列ss中的<訊息，處理函式>對，具體原理詳見示例3.6、3.7、3.8。
	while(s1->msgid!=0){  
		if(s1->msg==msg){s2=s1;	meff.pf=s2->pf;
switch(s2->msgid) /*根據結構體S中的成員msgid的值，判斷使用共用體UN中的哪一個成員呼叫訊息處理函式，在MFC原始碼中，msgid是使用一個比較龐大的列舉來設定其與共用體UN相關聯的值的，本例為簡化原理，使用一個任意值。*/
{case 1:{(this->*meff.pf_0)(w,l); /*❻、this指標不能省略，否則是錯誤的，因為使用指向類成員的指標，必須通過類的物件或指標進行呼叫。此處pf_0是指向類成員函式的指標。*/
return 0;}
case 3:return 0;   /*呼叫其他的訊息處理函式處理訊息的程式碼，略，在MFC原始碼中，該swtich結構是很龐大的，因為他包含了所有可能的訊息處理函式的原型的呼叫，本示例是一個簡化示例。*/
			case 4:return 0;}	}  
		s1++;  }//while迴圈結束。
	if(s2==0) ;	

	switch (msg) {
	case WM_DESTROY: {	PostQuitMessage(0);	break; }
	default:return ::DefWindowProc(h1, msg, w, l);	}
	return 0;}
BOOL A::InitInstance(){   	m_pMainWnd=new B();  
		m_pMainWnd->ShowWindow(m_nCmdShow);	m_pMainWnd->UpdateWindow();
		HWND hh1=FindWindow(0,"HYONG"); 	SetWindowLong(hh1,GWLP_WNDPROC,(LONG)gg); 
		return TRUE;}
A ma;

執行結果如下： 在這裡插入圖片描述

本文作者：黃邦勇帥(原名：黃勇)

相關推薦

VC++/MFC訊息對映機制(1)：MFC訊息對映原理

VC++/MFC訊息對映機制(1)：模仿MFC的訊息對映原理 本文要求對C++語法比較熟悉(特別是虛擬函式的使用)，若不熟悉建議參閱《C++語法詳解》一書，電子工業出版社出版 1、訊息對映：就是把指定的訊息交給指定的函式進行處理的方法，這樣就形成了一個<訊息，處理函式>對。

MFC訊息對映原理

模仿MFC的訊息對映原理 本文要求對C++語法比較熟悉(特別是虛擬函式的使用)，若不熟悉建議參閱《C++語法詳解》一書，電子工業出版社出版 1、訊息對映：就是把指定的訊息交給指定的函式進行處理的方法，這樣就形成了一個<訊息，處理函式>對。 2、本文有

VC++/MFC訊息對映機制(2)：MFC訊息路由原理

VC++/ MFC訊息對映機制(2)：模仿MFC的訊息路由 本文要求對C++語法比較熟悉(特別是虛擬函式的使用)，若不熟悉建議參閱《C++語法詳解》一書，電子工業出版社出版。並且本文需結合上一篇文章《MFC訊息對映原理》閱讀。 訊息路由的目的就是把當前類沒有處理的訊息，上傳給其父類進

VC++/MFC訊息對映機制(4)：附：鉤子函式原理

VC++/MFC訊息對映機制(4)：附：鉤子函式原理 若對C++語法不熟悉，建議參閱《C++語法詳解》一書，電子工業出版社出版，該書語法示例短小精悍，對查閱C++知識點相當方便，並對語法原理進行了透徹、深入詳細的講解。 一、鉤子SetWindowsHookEx 注意：本文的鉤子和

MFC訊息對映機制(2)：MFC訊息路由原理

MFC訊息對映機制(2)：模仿MFC的訊息路由 本文要求對C++語法比較熟悉(特別是虛擬函式的使用)，若不熟悉建議參閱《C++語法詳解》一書，電子工業出版社出版。並且本文需結合上一篇文章《MFC訊息對映原理》閱讀。 訊息路由的目的就是把當前類沒有處理的訊息，上傳

MFC原始碼實戰分析（三）——訊息對映原理與訊息路由機制初探

如果在看完上一篇文章後覺得有點暈，不要害怕。本節我們就不用這些巨集，而是用其中的內容重新完成開頭那個程式，進而探究MFC訊息對映的本來面目。 MFC訊息對映機制初探 還我本來面目 class CMyWnd : public CFrameWnd

MFC訊息對映的原理

原文地址：http://www.cnblogs.com/lidabo/p/3694726.html 多型的實現機制有兩種，一是通過查詢絕對位置表，二是查詢名稱表；兩者各有優缺點，那麼為什麼mfc的訊息對映採用了第二種方法，而不是c++使用的第一種呢？因為在mfc的gui

MFC訊息對映機制的理解

當窗體，控制元件，點選標題欄等時，會產生訊息，然後發給訊息處理函式進行處理，而訊息與訊息對映表是一一對應的關係，這個關係就是訊息對映表，根據根據訊息通過訊息對映表來查詢對應的訊息處理函式，這就稱為訊息對映機制。 而Windows有自己的訊息佇列，通過訊息迴圈，採用GetMessage來獲取訊

VC++/MFC訊息對映機制(3)：MFC訊息路由的原始碼分析

VC++/MFC訊息對映機制(3)：MFC訊息路由的原始碼分析 若對C++語法不熟悉，建議參閱《C++語法詳解》一書，電子工業出版社出版，該書語法示例短小精悍，對查閱C++知識點相當方便，並對語法原理進行了透徹、深入詳細的講解。 注意：本文最好結合本人所作前兩篇與訊息對映機制有關的文章一

解讀ATL/WTL/MFC訊息對映的實現方式

在我們編寫WTL程式的時候，如下的訊息對映我們很熟悉: BEGIN_MSG_MAP(CMainDlg)  MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)  COMMAND_ID_HANDLER(ID_CATALOG

MFC 訊息對映巨集的單純展開（無解析）

MFC訊息對映巨集的展開 BEGIN_MESSAGE_MAP (CMainWindow, CFrameWnd) ON_WM_PAINT () //WM_PAINT 訊息通過MFC的訊息對映機制轉換為對CMainWindow：：OnPaint函式的呼叫 END_MESSA

MFC訊息對映筆記

大家有沒有思考過當一個訊息出現，應用程式框架是如何將訊息與物件建立關係的？ 1.訊息巨集 為了支援訊息對映，MFC提供了3種巨集。 1.1訊息對映的宣告和分解巨集 訊息對映的宣告和分界巨集包含在CCmdTarget類中，如下表： 就是這3個

VC----MFC訊息對映機制詳解

Windows程式和MFC程式是靠訊息驅動的，他們對於訊息的處理本質上是相同的。只是Windows程式對於訊息處理的過程十分清晰明瞭，MFC程式則掩蓋了訊息處理的過程，以訊息對映的方式呈現在開發者面前，使得開發訊息的處理十分簡單。用多了mfc就想對它的訊息對映機制有一個本

MFC學習（二）：訊息對映

1. 訊息對映表的組成 巨集DECLARE_MESSAGE_MAP，用在類的宣告中，用來宣告訊息對映表。 巨集BEGIN_MESSAGE_MAP，在使用類宣告外，用來定義連結節點和填寫連結串列節點中的資料，其格式為BEGIN_MESSAGE_MAP(類名稱, 基類名稱)。 巨集ON_XXXX，

《深入淺出MFC》第九章 訊息對映與命令傳遞

Windows程式的本質是藉著訊息來維持脈動。每個訊息都有一個程式碼，並以WM_開頭的常量表示。來自選單和工具欄者，都以WM_COMMAND表示，引數wParam記錄訊息的發出者。 MFC的訊息分為三大類，命令訊息（WM_COMMAND），凡派生自CCmdTarget的類都有資格接收命令訊息。除WM_COM

MFC(2)：底層實現視窗、MFC視窗建立與訊息對映、windows字符集和嚮導的使用

=====================從底層去實現一個視窗=============== 程式入口是WinMain函式 視窗的建立步驟： -->  設計（WNDCLASS）  -->  註冊（RegisterClass）  -->

MFC六大關鍵技術之——訊息對映與命令傳遞

1 BOOL CWnd::OnWndMsg(UINT message,WPARAM wParam,LPARAM lParam,LRESULT* pResult)2 {3 if(message==WM_COMMAND)4 {5 OnCommand(wParam,lParam);6 ……7 }8 9 if(mes

利用MFC建立視窗、訊息對映、window中的位元組

利用MFC建立視窗： 1、mfc的標頭檔案：afxwin.h 2、自定義類，繼承於CWinApp，應用程式類（app應用程式物件，有且僅有一個） 3、程式入口：Initinstance 4、在程式入口中建立視窗 5、視窗類繼承於CFrameWind 6、視窗中構造Create（NULL，標題名稱）

MFC之訊息對映機制實現方法

訊息對映初見 我們新建一個Draw單文件工程後，通過在DrawView類中新增一個“滑鼠左鍵按下的訊息”進行訊息對映機制的分析，在分析之前，先 完成“WM_LButtonDown”訊息響應函式的新增

MFC訊息機制---訊息對映

Win32程式訊息流動 在講MFC訊息機制之前，先來介紹一下Win32程式的訊息處理。 Win32程式的編寫流程一般就分為：註冊視窗，建立視窗，顯示視窗，更新視窗， 訊息迴圈，訊息處理。 Win32程式執行起來後，會在如下程式碼進行訊息迴圈： while(GetMess