今天在網上突然發現了下面幾個關于c代碼中的宏定義的說明，回想下，好像在系統的代碼中也見過這些零散的定義，但沒有注意，看到別人總結了下，發現果然很有用，雖然不知有的道可用與否，但也不失為一種手段，所以就先把它摘抄下來，增加一點見識：
1,防止一個頭文件被重復包含
#ifndef BODYDEF_H
#define BODYDEF_H
//頭文件內容
#endif
2,得到指定地址上的一個字節或字
#define MEM_B( x ) ( *( (byte *) (x) ) )
#define MEM_W( x ) ( *( (word *) (x) ) )
3,得到一個field在結構體(struct)中的偏移量
#define FPOS( type, field ) ( (dword) &(( type *) 0)-> field )
4,得到一個結構體中field所占用的字節數
#define FSIZ( type, field ) sizeof( ((type *) 0)->field )
5,得到一個變量的地址（word寬度）
#define B_PTR( var ) ( (byte *) (void *) &(var) )
#define W_PTR( var ) ( (word *) (void *) &(var) )
6,將一個字母轉換為大寫
#define UPCASE( c ) ( ((c) >= ''a'' && (c) <= ''z'') ? ((c) - 0x20) : (c) )
7,判斷字符是不是10進值的數字
#define DECCHK( c ) ((c) >= ''0'' && (c) <= ''9'')
8,判斷字符是不是16進值的數字
#define HEXCHK( c ) ( ((c) >= ''0'' && (c) <= ''9'') ||((c) >= ''A'' && (c) <= ''F'') ||((c) >= ''a'' && (c) <= ''f'') )
9,防止溢出的一個方法
#define INC_SAT( val ) (val = ((val)+1 > (val)) ? (val)+1 : (val))
10,返回數組元素的個數
#define ARR_SIZE( a ) ( sizeof( (a) ) / sizeof( (a[0]) ) )
11,使用一些宏跟蹤調試
ANSI標準說明了五個預定義的宏名。它們是：
_LINE_ (兩個下劃線)，對應%d
_FILE_ 對應%s
_DATE_ 對應%s
_TIME_ 對應%s
_STDC_
宏中"#"和"##"的用法
我們使用#把宏參數變為一個字符串,用##把兩個宏參數貼合在一起.
#define STR(s) #s
#define CONS(a,b) int(a##e##b)
Printf(STR(vck)); // 輸出字符串"vck"
printf("%d\n", CONS(2,3)); // 2e3 輸出:2000
當宏參數是另一個宏的時候
需要注意的是凡宏定義里有用"#"或"##"的地方宏參數是不會再展開.
#define A (2)
#define STR(s) #s
#define CONS(a,b) int(a##e##b)
printf("%s\n", CONS(A, A)); // compile error
這一行則是：
printf("%s\n", int(AeA));
INT_MAX和A都不會再被展開, 然而解決這個問題的方法很簡單. 加多一層中間轉換宏.
加這層宏的用意是把所有宏的參數在這層里全部展開, 那么在轉換宏里的那一個宏(_STR)就能得到正確的宏參數
#define STR(s) _STR(s) // 轉換宏
#define CONS(a,b) _CONS(a,b) // 轉換宏
printf("int max: %s\n", STR(INT_MAX)); // INT_MAX,int型的最大值,為一個變量 #include<climits>
輸出為: int max: 0x7fffffff
STR(INT_MAX) --> _STR(0x7fffffff) 然后再轉換成字符串;
printf("%d\n", CONS(A, A));
輸出為：200
CONS(A, A) --> _CONS((2), (2)) --> int((2)e(2))
"#"和"##"的一些應用特例
1、合并匿名變量名
#define ___ANONYMOUS1(type, var, line) type var##line
#define __ANONYMOUS0(type, line) ___ANONYMOUS1(type, _anonymous, line)
#define ANONYMOUS(type) __ANONYMOUS0(type, __LINE__)
例：ANONYMOUS(static int); 即: static int _anonymous70; 70表示該行行號;
第一層：ANONYMOUS(static int); --> __ANONYMOUS0(static int, __LINE__);
第二層： --> ___ANONYMOUS1(static int, _anonymous, 70);
第三層： --> static int _anonymous70;
即每次只能解開當前層的宏,所以__LINE__在第二層才能被解開;
2、填充結構
#define FILL(a) {a, #a}
enum IDD{OPEN, CLOSE};
typedef struct MSG{
IDD id;
const char * msg;
}MSG;
MSG _msg[] = {FILL(OPEN), FILL(CLOSE)};
相當于：
MSG _msg[] = {{OPEN, "OPEN"},
{CLOSE, "CLOSE"}};
3、記錄文件名
#define _GET_FILE_NAME(f) #f
#define GET_FILE_NAME(f) _GET_FILE_NAME(f)
static char FILE_NAME[] = GET_FILE_NAME(__FILE__);
4、得到一個數值類型所對應的字符串緩沖大小
#define _TYPE_BUF_SIZE(type) sizeof #type
#define TYPE_BUF_SIZE(type) _TYPE_BUF_SIZE(type)
char buf[TYPE_BUF_SIZE(INT_MAX)];
--> char buf[_TYPE_BUF_SIZE(0x7fffffff)];
--> char buf[sizeof "0x7fffffff"];
這里相當于：
char buf[11];
C++提供的編譯預處理功能主要有以下三種：
（一） 宏定義
（二） 文件包含
（三） 條件編譯
在C++中，我們一般用const定義符號常量。很顯然，用const定義常量比用define定義常量更好。
在使用宏定義時應注意的是：
（a） 在書寫#define 命令時，注意<宏名>和<字符串>之間用空格分開，而不是用等號連接。
（b） 使用#define定義的標識符不是變量，它只用作宏替換，因此不占有內存。
（c） 習慣上用大寫字母表示<宏名>，這只是一種習慣的約定，其目的是為了與變量名區分，因為變量名
通常用小寫字母。
如果某一個標識符被定義為宏名后，在取消該宏定義之前，不允許重新對它進行宏定義。取消宏定義使用如下命令：
#undef<標識符>
其中，undef是關鍵字。該命令的功能是取消對<標識符>已有的宏定義。被取消了宏定義的標識符，可以對它重新進行定義。
宏定義可以嵌套，已被定義的標識符可以用來定義新的標識符。例如：
#define PI 3.14159265
#define R 10
#define AREA (PI*R*R)
單的宏定義將一個標識符定義為一個字符串，源程序中的該標識符均以指定的字符串來代替。前面已經說過，預處理命令不同于一般C++語句。因此預處理命令后通常不加分號。這并不是說所有的預處理命令后都不能有分號出現。由于宏定義只是用宏名對一個字符串進行簡單的替換，因此如果在宏定義命令后加了分號，將會連同分號一起進行置換。
帶參數的宏定義
帶參數的宏定義的一般形式如下：
#define <宏名>（<參數表>） <宏體>
其中， <宏名>是一個標識符，<參數表>中的參數可以是一個，也可以是多個，視具體情況而定，當有多個參數的時候，每個參數之間用逗號分隔。<宏體>是被替換用的字符串，宏體中的字符串是由參數表中的各個參數組成的表達式。例如：
#define SUB(a,b) a-b
如果在程序中出現如下語句：
result=SUB(2, 3)
則被替換為：
result=2-3；
如果程序中出現如下語句：
result= SUB（x+1, y+2）;
則被替換為：
result=x+1-y+2;
在這樣的宏替換過程中，其實只是將參數表中的參數代入到宏體的表達式中去，上述例子中，即是將表達式中的a和b分別用2和3代入。
我們可以發現：帶參的宏定義與函數類似。如果我們把宏定義時出現的參數視為形參，而在程序中引用宏定義時出現的參數視為實參。那么上例中的a和b就是形參，而2和3以及x+1和y+2都為實參。在宏替換時，就是用實參來替換<宏體>中的形參。
在使用帶參數的宏定義時需要注意的是：
（1）帶參數的宏定義的<宏體>應寫在一行上，如果需要寫在多行上時，在每行結束時，使用續行符 "\"結
束，并在該符號后按下回車鍵，最后一行除外。
（2）在書寫帶參數的宏定義時，<宏名>與左括號之間不能出現空格，否則空格右邊的部分都作為宏體。
例如：
#define ADD (x,y) x+y
將會把"（x,y）x+y"的一個整體作為被定義的字符串。
（3）定義帶參數的宏時，宏體中與參數名相同的字符串適當地加上圓括號是十分重要的，這樣能夠避免
可能產生的錯誤。例如,對于宏定義：
#define SQ(x) x*x
當程序中出現下列語句：
m=SQ(a+b);
替換結果為：
m=a+b*a+b;
這可能不是我們期望的結果，如果需要下面的替換結果：
m=(a+b)*(a+b);
應將宏定義修改為：
#define SQ(x) (x)*(x)
對于帶參的宏定義展開置換的方法是：在程序中如果有帶實參的宏（如"SUB（2,3）"），則按"#define"命令行中指定的字符串從左到右進行置換。如果串中包含宏中的形參（如a、b），則將程序語句中相應的實參（可以是常量、變量或者表達式）代替形參，如果宏定義中的字符串中的字符不是參數字符（如a-b中的-號），則保留。這樣就形成了置換的字符串。 C++提供的編譯預處理功能主要有以下三種：
（一） 宏定義
（二） 文件包含
（三） 條件編譯
在C++中，我們一般用const定義符號常量。很顯然，用const定義常量比用define定義常量更好。
在使用宏定義時應注意的是：
（a） 在書寫#define 命令時，注意<宏名>和<字符串>之間用空格分開，而不是用等號連接。
（b） 使用#define定義的標識符不是變量，它只用作宏替換，因此不占有內存。
（c） 習慣上用大寫字母表示<宏名>，這只是一種習慣的約定，其目的是為了與變量名區分，因為變量名
通常用小寫字母。
如果某一個標識符被定義為宏名后，在取消該宏定義之前，不允許重新對它進行宏定義。取消宏定義使用如下命令：
#undef<標識符>
其中，undef是關鍵字。該命令的功能是取消對<標識符>已有的宏定義。被取消了宏定義的標識符，可以對它重新進行定義。
宏定義可以嵌套，已被定義的標識符可以用來定義新的標識符。例如：
#define PI 3.14159265
#define R 10
#define AREA (PI*R*R)
單的宏定義將一個標識符定義為一個字符串，源程序中的該標識符均以指定的字符串來代替。前面已經說過，預處理命令不同于一般C++語句。因此預處理命令后通常不加分號。這并不是說所有的預處理命令后都不能有分號出現。由于宏定義只是用宏名對一個字符串進行簡單的替換，因此如果在宏定義命令后加了分號，將會連同分號一起進行置換。
帶參數的宏定義
帶參數的宏定義的一般形式如下：
#define <宏名>（<參數表>） <宏體>
其中， <宏名>是一個標識符，<參數表>中的參數可以是一個，也可以是多個，視具體情況而定，當有多個參數的時候，每個參數之間用逗號分隔。<宏體>是被替換用的字符串，宏體中的字符串是由參數表中的各個參數組成的表達式。例如：
#define SUB(a,b) a-b
如果在程序中出現如下語句：
result=SUB(2, 3)
則被替換為：
result=2-3；
如果程序中出現如下語句：
result= SUB（x+1, y+2）;
則被替換為：
result=x+1-y+2;
在這樣的宏替換過程中，其實只是將參數表中的參數代入到宏體的表達式中去，上述例子中，即是將表達式中的a和b分別用2和3代入。
我們可以發現：帶參的宏定義與函數類似。如果我們把宏定義時出現的參數視為形參，而在程序中引用宏定義時出現的參數視為實參。那么上例中的a和b就是形參，而2和3以及x+1和y+2都為實參。在宏替換時，就是用實參來替換<宏體>中的形參。
在使用帶參數的宏定義時需要注意的是：
（1）帶參數的宏定義的<宏體>應寫在一行上，如果需要寫在多行上時，在每行結束時，使用續行符 "\"結
束，并在該符號后按下回車鍵，最后一行除外。
（2）在書寫帶參數的宏定義時，<宏名>與左括號之間不能出現空格，否則空格右邊的部分都作為宏體。
例如：
#define ADD (x,y) x+y
將會把"（x,y）x+y"的一個整體作為被定義的字符串。
（3）定義帶參數的宏時，宏體中與參數名相同的字符串適當地加上圓括號是十分重要的，這樣能夠避免
可能產生的錯誤。例如,對于宏定義：
#define SQ(x) x*x
當程序中出現下列語句：
m=SQ(a+b);
替換結果為：
m=a+b*a+b;
這可能不是我們期望的結果，如果需要下面的替換結果：
m=(a+b)*(a+b);
應將宏定義修改為：
#define SQ(x) (x)*(x)
對于帶參的宏定義展開置換的方法是：在程序中如果有帶實參的宏（如"SUB（2,3）"），則按"#define"命令行中指定的字符串從左到右進行置換。如果串中包含宏中的形參（如a、b），則將程序語句中相應的實參（可以是常量、變量或者表達式）代替形參，如果宏定義中的字符串中的字符不是參數字符（如a-b中的-號），則保留。這樣就形成了置換的字符串。
解剖MFC自動生成的宏定義
一、關于DECLARE_MESSAGE_MAP宏定義
使用MFC向導，在ApplicationType頁面選擇DialogBased，生成一個對話框項目，Dialog類命名為CCapturePacketDlg，在CCapturePacketDlg.cpp中自動產生下列代碼：
1 
BEGIN_MESSAGE_MAP(CCapturePacketDlg, CDialog)
2 ON_WM_PAINT()
3 END_MESSAGE_MAP()
- 先來分析ON_WM_PAINT()，在頭文件“afxmsg.h”有它的宏定義，如下：
1 #define ON_WM_PAINT() \
2 
{ WM_PAINT, 0 , 0 , 0 , AfxSig_vv, \
3 
(AFX_PMSG)(AFX_PMSGW) \
4 
(static_cast < void (AFX_MSG_CALL CWnd:: * )( void ) > ( & ThisClass :: OnPaint)) } ,
說明：層次序號x.y.z表示x為根節點也就是上面代碼中的行號，y、z為上一級的定義展開。
2.1 #define WM_PAINT 0x000F
2.2 AfxSig_vv = AfxSig_v_v_v
2.2.1 enum AfxSig::AfxSig_v_v_v = 19
3.1 AFX_PMSG：typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void); //為一個函數指針
3.2 AFX_PMSGW：typedef void (AFX_MSG_CALL CWnd::*AFX_PMSGW)(void); //為一個函數指針
將ON_WM_PAINT()完全展開：
1{
2 0x000F,
3 0,
4 0,
5 0,
6 19,
7 //Converts OnPaint to the type of CCmdTarget finally. Derive Class 's pointer -> Base Class's pointer
8 (AFX_MSG_CALL CCmdTarget::*)((AFX_MSG_CALL CWnd::*)(static_cast< void (AFX_MSG_CALL CWnd::*)(void) >(&ThisClass :: OnPaint))
9 }
2. 再來分析BEGIN_MESSAGE_MAP(CCapturePacketDlg, CDialog)，在“afxwin.h”中有定義：
1#define BEGIN_MESSAGE_MAP(theClass, baseClass) \
2 PTM_WARNING_DISABLE \
3 const AFX_MSGMAP* theClass::GetMessageMap() const \
4 { return GetThisMessageMap(); } \
5 const AFX_MSGMAP* PASCAL theClass::GetThisMessageMap() \
6 { \
7 typedef theClass ThisClass; \
8 typedef baseClass TheBaseClass; \
9 static const AFX_MSGMAP_ENTRY _messageEntries[] = \
10
{
2.1 PTM_WARNING_DISABLE：
#define PTM_WARNING_DISABLE \
__pragma(warning( push )) \ //#pragma warning( push [ ,n ] ),Where n represents a warning level (1 through 4).
//The pragma warning( push ) stores the current warning state for all warnings.
__pragma(warning( disable : 4867 ))//Do not issue the specified warning message(s).
//http://msdn2.microsoft.com/en-us/2c8f766e.aspx
// Allows selective modification of the behavior of compiler warning messages.
3.1 struct AFX_MSGMAP
{
3.1.1 const AFX_MSGMAP* (PASCAL* pfnGetBaseMap)();
3.1.2 const AFX_MSGMAP_ENTRY* lpEntries;
};
3.1.2 struct AFX_MSGMAP_ENTRY
{
UINT nMessage; // windows message
UINT nCode; // control code or WM_NOTIFY code
UINT nID; // control ID (or 0 for windows messages)
UINT nLastID; // used for entries specifying a range of control id's
UINT_PTR nSig; // signature type (action) or pointer to message #
3.1.2.1 AFX_PMSG pfn; // routine to call (or special value)
};
3.1.2.1 typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void);
5.1 #define PASCAL __stdcall
將BEGIN_MESSAGE_MAP(CCapturePacketDlg, CDialog)完全展開：
1__pragma(warning( push )) __pragma(warning( disable : 4867 ))
2 const struct AFX_MSGMAP* CCapturePacketDlg::GetMessageMap() const
3 {
4 return GetThisMessageMap();
5 }
6 const struct AFX_MSGMAP* __stdcall CCapturePacketDlg::GetThisMessageMap()
7 {
8 typedef CCapturePacketDlg ThisClass;
9 typedef CDialog TheBaseClass;
10 static const struct AFX_MSGMAP_ENTRY _messageEntries[] =
11 {
3 最后分析END_MESSAGE_MAP()，在“afxwin.h”中有定義：
1#define END_MESSAGE_MAP() \
2 {0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \
3 }; \
4 static const AFX_MSGMAP messageMap = \
5 { &TheBaseClass::GetThisMessageMap, &_messageEntries[0] }; \
6 return &messageMap; \
7 } \
8 PTM_WARNING_RESTORE
2.1 AfxSig_end：enum AfxSig.AfxSig_end = 0
2.2 AFX_PMSG：typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void);//函數指針
4.1 struct AFX_MSGMAP
{
const AFX_MSGMAP* (PASCAL* pfnGetBaseMap)();
const AFX_MSGMAP_ENTRY* lpEntries;
};
8.1 #define PTM_WARNING_RESTORE \
__pragma(warning( pop ))
//pop restores the state of all warnings (including 4705, 4706, and 4707) to what it was at the beginning of the code.
·最后將
1BEGIN_MESSAGE_MAP(CCapturePacketDlg, CDialog)
2 ON_WM_PAINT()
3END_MESSAGE_MAP()
完全展開為：
1__pragma(warning( push )) __pragma(warning( disable : 4867 ))
2 const struct AFX_MSGMAP* CCapturePacketDlg::GetMessageMap() const
3 {
4 return GetThisMessageMap();
5 }
6 const struct AFX_MSGMAP* __stdcall CCapturePacketDlg::GetThisMessageMap()
7 {
8 typedef CCapturePacketDlg ThisClass;
9 typedef CDialog TheBaseClass;
10 static const struct AFX_MSGMAP_ENTRY _messageEntries[] =
11 {
12 {
13 0x000F,
14 0,
15 0,
16 0,
17 19,
18 //Converts OnPaint to the type of CCmdTarget finally. Derive Class 's pointer -> Base Class's pointer
19 (AFX_MSG_CALL CCmdTarget::*)((AFX_MSG_CALL CWnd::*)(static_cast< void (AFX_MSG_CALL CWnd::*)(void) >(&ThisClass :: OnPaint))
20
},
21 //add others
22 {
23 0,
24 0,
25 0,
26 0,
27 0,
28 (AFX_PMSG)0
29 }
30 }
31 static const struct AFX_MSGMAP messageMap =
32 {
33 &TheBaseClass::GetThisMessageMap,
34 &_messageEntries[0]
35 };
36 return &messageMap;
37 }
38__pragma(warning( pop ))
39
其中GetMessageMap()是在哪里聲明的呢？在CCapturePacketDlg的定義中有一個這樣的宏：DECLARE_MESSAGE_MAP()
老辦法查看它的定義：
1#define DECLARE_MESSAGE_MAP() \
2protected: \
3 static const AFX_MSGMAP* PASCAL GetThisMessageMap(); \
4 virtual const AFX_MSGMAP* GetMessageMap() const; \
注意函數為static，即它們是類的函數。函數中的static變量實際也在類對象未生成之前已經存在。(這種說法不知道是否正確？)
小結：
每次用MFC類向導生成一個類時，系統會在類的聲明部分添加兩個方法的聲明：GetThisMessageMap()，GetMessageMap()。在類的實現部分.cpp文件中加上這兩個方法的定義。
當然這所有的代碼都是由系統生成的，如果我們要定義自己的消息處理函數呢，例如，我們要添加一個按鈕（ID為：IDC_BUTTON1）的單擊處理函數我們可以添加宏ON_NOTIFY(NM_CLICK, IDC_BUTTON1, OnMyClick)，OnMyClick為自定義函數，但是他必須與ON_NOTIFY中的函數原型一致。
二、關于DECLARE_DYNCREATE宏
使用MFC向導，在ApplicationType頁面選擇SingleDocument，生成一個單文檔項目，Document類命名為CDynamicDoc，在CDynamicDoc.h中自動產生DECLARE_DYNCREATE(CDynamicDoc)，CDynamicDoc.cpp中產生IMPLEMENT_DYNCREATE(CDynamicDoc, CDocument)。
1、展開CDynamicDoc.h中的DECLARE_DYNCREATE(CDynamicDoc)：
1// not serializable, but dynamically constructable
2 #define DECLARE_DYNCREATE(class_name) \
3 DECLARE_DYNAMIC(class_name) \
4 static CObject* PASCAL CreateObject();
3.1如下定義：
1#ifdef _AFXDLL
2 #define DECLARE_DYNAMIC(class_name) \
3 protected: \
4 static CRuntimeClass* PASCAL _GetBaseClass(); \
5 public: \
6 static const CRuntimeClass class##class_name; \
7 static CRuntimeClass* PASCAL GetThisClass(); \
8 virtual CRuntimeClass* GetRuntimeClass() const; \
so the result(DECLARE_DYNCREATE(CDynamicDoc)) of combining the above two is following:
1protected:
2 static CRuntimeClass* PASCAL _GetBaseClass();
3 public:
4 static const CRuntimeClass classCDynamicDoc;
5 static CRuntimeClass* PASCAL GetThisClass();
6 virtual CRuntimeClass* GetRuntimeClass() const;
7 static CObject* PASCAL CreateObject();
2、展開CDynamicDoc.cpp中的IMPLEMENT_DYNCREATE(CDynamicDoc, CDocument)：
1#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \
2 CObject* PASCAL class_name::CreateObject() \
3 { return new class_name; } \
4 IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \
5 class_name::CreateObject, NULL)
4.1如下定義：
1#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew, class_init) \
2 CRuntimeClass* PASCAL class_name::_GetBaseClass() \
3 { return RUNTIME_CLASS(base_class_name); } \
4 AFX_COMDAT const CRuntimeClass class_name::class##class_name = { \
5 #class_name, sizeof(class class_name), wSchema, pfnNew, \
6 &class_name::_GetBaseClass, NULL, class_init }; \
7 CRuntimeClass* PASCAL class_name::GetThisClass() \
8 { return _RUNTIME_CLASS(class_name); } \
9 CRuntimeClass* class_name::GetRuntimeClass() const \
10 { return _RUNTIME_CLASS(class_name); } \
4.1.2 CRuntimeClass如下定義：
1struct CRuntimeClass
2 {
3 // Attributes
4 LPCSTR m_lpszClassName;
5 int m_nObjectSize;
6 UINT m_wSchema; // schema number of the loaded class
7 CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class
8 #ifdef _AFXDLL
9 CRuntimeClass* (PASCAL* m_pfnGetBaseClass)();
10 #else
11 CRuntimeClass* m_pBaseClass;
12 #endif
13
14 // Operations
15 CObject* CreateObject();
16 BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;
17
18 // dynamic name lookup and creation
19 static CRuntimeClass* PASCAL FromName(LPCSTR lpszClassName);
20 static CRuntimeClass* PASCAL FromName(LPCWSTR lpszClassName);
21 static CObject* PASCAL CreateObject(LPCSTR lpszClassName);
22 static CObject* PASCAL CreateObject(LPCWSTR lpszClassName);
23
24 // Implementation
25 void Store(CArchive& ar) const;
26 static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum);
27
28 // CRuntimeClass objects linked together in simple list
29 CRuntimeClass* m_pNextClass; // linked list of registered classes
30 const AFX_CLASSINIT* m_pClassInit;
31 };
4.1.2.30 AFX_CLASSINIT如下定義：（這個變量非常重要，它完成了將新的類加在List頭部的功能，List中的節點類型就是CRuntimeClass）
1/**////////////////////////////////////////////////////////////////////////////// 2 // Basic object model
3
4 // generate static object constructor for class registration
5 void AFXAPI AfxClassInit(CRuntimeClass* pNewClass);
6 struct AFX_CLASSINIT
7 { AFX_CLASSINIT(CRuntimeClass* pNewClass) { AfxClassInit(pNewClass); } };
8 //C:\Program Files\Microsoft Visual Studio 8\VC\atlmfc\src\mfc\objcore.cpp Line157
9 void AFXAPI AfxClassInit(CRuntimeClass* pNewClass)
10 {
11 AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
12 AfxLockGlobals(CRIT_RUNTIMECLASSLIST);
13 pModuleState->m_classList.AddHead(pNewClass);
14 AfxUnlockGlobals(CRIT_RUNTIMECLASSLIST);
15 }
16 //可以將AfxClassInit()函數的功能簡單的如下表示：
17 AFX_CLASSINIT::AFX_CLASSINIT(CRuntimeClass* pNewClass)
18 {
19 pNewClass->m_pNextClass = CRuntimeClass::pFirstClass;
20 CRuntimeClass::pFirstClass = pNewClass;
21 }
4.1.3 RUNTIME_CLASS如下定義：
1#define RUNTIME_CLASS(class_name) (class_name::GetThisClass())
4.1.4 AFX_COMDAT如下定義：
1#define AFX_COMDAT __declspec(selectany)
說明：“#”——operator (#) converts macro parameters to string literals without expanding the parameter definition.
“##”——operator (
##), which is sometimes called the "merging" operator, is used in both object-like and function-like macros.
4.1.8 _RUNTIME_CLASS如下定義：
1#define _RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name))
so the result(IMPLEMENT_DYNCREATE(CDynamicDoc, CDocument)) of combining the aboves is following:
1//CDynamicDoc, CDocument->class_name, base_class_name
2 static CObject* PASCAL CDynamicDoc::CreateObject()
3 {
4 return new CDynamicDoc;
5 }
6
7 static CRuntimeClass* PASCAL CDynamicDoc::_GetBaseClass()
8 {
9 return CDocument::GetThisClass()
10 }
11
12 __declspec(selectany) static const CRuntimeClass CDynamicDoc::classCDynamicDoc =
13 {
14 "CDynamicDoc"
15 , sizeof(class CDynamicDoc)
16 , 0xFFFF
17 , CDynamicDoc::CreateObject
18 , &CDynamicDoc::_GetBaseClass
19 , NULL
20 , NULL
21 };
22
23 static CRuntimeClass* PASCAL CDynamicDoc::GetThisClass()
24 {
25 return ((CRuntimeClass*)(&CDynamicDoc::classCDynamicDoc));
26 }
27
28 CRuntimeClass* CDynamicDoc::GetRuntimeClass() const
29 {
30 return ((CRuntimeClass*)(&CDynamicDoc::classCDynamicDoc));
31 }
小結：注意了，上面的成員變量、很多函數都是static
如果你想看這些宏的簡化版，可以參考侯老的《深入淺出MFC》，如下：
三、宏DECLARE_SERIAL(CStroke)、IMPLEMENT_SERIAL(CStroke, CObject, 1)，給出它們的宏定義及結果：
1//declaration file
2#define DECLARE_SERIAL(class_name) \
3 _DECLARE_DYNCREATE(class_name) \
4 AFX_API friend CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb);
5
6 #define _DECLARE_DYNCREATE(class_name) \
7 _DECLARE_DYNAMIC(class_name) \
8 static CObject* PASCAL CreateObject();
9
10 #define _DECLARE_DYNAMIC(class_name) \
11 protected: \
12 static CRuntimeClass* PASCAL _GetBaseClass(); \
13 public: \
14 static CRuntimeClass class##class_name; \
15 static CRuntimeClass* PASCAL GetThisClass(); \
16 virtual CRuntimeClass* GetRuntimeClass() const; \
17//implement file
18#define IMPLEMENT_SERIAL(class_name, base_class_name, wSchema) \
19 CObject* PASCAL class_name::CreateObject() \
20 { return new class_name; } \
21 extern AFX_CLASSINIT _init_##class_name; \
22 _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, \
23 class_name::CreateObject, &_init_##class_name) \
24 AFX_CLASSINIT _init_##class_name(RUNTIME_CLASS(class_name)); \
25 CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb) \
26 { pOb = (class_name*) ar.ReadObject(RUNTIME_CLASS(class_name)); \
27 return ar; } \
28
29 // generate static object constructor for class registration
30 void AFXAPI AfxClassInit(CRuntimeClass* pNewClass);
31 struct AFX_CLASSINIT
32 { AFX_CLASSINIT(CRuntimeClass* pNewClass) { AfxClassInit(pNewClass); } };
33
34 void AFXAPI AfxClassInit(CRuntimeClass* pNewClass)
35 {
36 AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
37 AfxLockGlobals(CRIT_RUNTIMECLASSLIST);
38 pModuleState->m_classList.AddHead(pNewClass);
39 AfxUnlockGlobals(CRIT_RUNTIMECLASSLIST);
40 }
41
42
43 #define _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew, class_init) \
44 CRuntimeClass* PASCAL class_name::_GetBaseClass() \
45 { return RUNTIME_CLASS(base_class_name); } \
46 AFX_COMDAT CRuntimeClass class_name::class##class_name = { \
47 #class_name, sizeof(class class_name), wSchema, pfnNew, \
48 &class_name::_GetBaseClass, NULL, class_init }; \
49 CRuntimeClass* PASCAL class_name::GetThisClass() \
50 { return _RUNTIME_CLASS(class_name); } \
51 CRuntimeClass* class_name::GetRuntimeClass() const \
52 { return _RUNTIME_CLASS(class_name); } \
53
54 #define _RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name))
55
56 #define RUNTIME_CLASS(class_name) (class_name::GetThisClass())
1//header file
2 protected:
3 static CRuntimeClass* PASCAL _GetBaseClass();
4 public:
5 static CRuntimeClass classCStroke;
6 static CRuntimeClass* PASCAL GetThisClass();
7 virtual CRuntimeClass* GetRuntimeClass() const;
8 static CObject* PASCAL CreateObject();
9 AFX_API friend CArchive& AFXAPI operator>>(CArchive& ar, CStroke* &pOb);
10//implement file
11 //static
12 static CObject* PASCAL CStroke::CreateObject()
13 {
14 return new CStroke;
15 }
16 //static
17 static CRuntimeClass* PASCAL CStroke::GetThisClass();
18 {
19 return ((CRuntimeClass*)(&CStroke::classCStroke))
20 }
21 //static
22 static CRuntimeClass* PASCAL CStroke::_GetBaseClass()
23 {
24 return (CObject::GetThisClass());
25 }
26 //static
27 static AFX_COMDAT CRuntimeClass CStroke::classCStroke =
28 {
29 "CStroke"
30 , sizeof(class CStroke)
31 , 1
32 , CStroke::CreateObject
33 , &class_name::_GetBaseClass
34 , NULL
35 , &_init_CStroke
36 };
37 CRuntimeClass* CStroke::GetRuntimeClass() const
38 {
39 return ((CRuntimeClass*)(&CStroke::classCStroke));
40 }
41 extern struct AFX_CLASSINIT _init_CStroke;
42 struct AFX_CLASSINIT _init_CStroke
43 {
44 void AFXAPI AfxClassInit(CRuntimeClass* CStroke)
45 {
46 AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
47 AfxLockGlobals(CRIT_RUNTIMECLASSLIST);
48 pModuleState->m_classList.AddHead(CStroke);
49 AfxUnlockGlobals(CRIT_RUNTIMECLASSLIST);
50 }
51 };
52 CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb)
53 {
54 pOb = (CStroke*) ar.ReadObject(RUNTIME_CLASS(CStroke));
55 return ar;
56 }
總結，一旦RUNTIME_CLASS(CStroke)由#define RUNTIME_CLASS(class_name) (class_name::GetThisClass())也就是CStroke::GetThisClass() 即
CStroke::classCStroke =
{
"CStroke"
, sizeof(class CStroke)
, 1
, CStroke::CreateObject
, &class_name::_GetBaseClass
, NULL
, &_init_CStroke
}
其中，由extern AFX_CLASSINIT _initCStroke可知_init_CStroke是一個結構體AFX_CLASSINIT的對象，此結構體有構造函數：
1void AFXAPI AfxClassInit(CRuntimeClass* pNewClass);
2 struct AFX_CLASSINIT
3 { AFX_CLASSINIT(CRuntimeClass* pNewClass) { AfxClassInit(pNewClass); } };
4
5 void AFXAPI AfxClassInit(CRuntimeClass* pNewClass)
6 {
7 AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
8 AfxLockGlobals(CRIT_RUNTIMECLASSLIST);
9 pModuleState->m_classList.AddHead(pNewClass);
10 AfxUnlockGlobals(CRIT_RUNTIMECLASSLIST);
11 }
所以一旦返回classCStroke，也就調用了_init_CStroke的構造函數即將類CStroke添加到了全局變量m_classList類的List中了，同時在變量classCStroke中，也可以得到類CStroke的名稱、大小、一個CStroke的對象、類CStroke的基類以及AFX_CLASSINIT結構的一個對象。