CMDIChildWnd/CFrameWnd CDocument/CView/CDocTemplate

萬個函式千個類發表於2013-01-04
CMDIChildWnd* pActiveChild = MDIGetActive();
CDocument* pDocument =  pActiveChild->GetActiveDocument();
CView* pVew = pActiveChild->GetActiveView();
CDocTemplate* pTemplate = pDocument->GetDocTemplate();

CFrameWnd* pFrame = pTemplate->CreateNewFrame(pDocument, pActiveChild);
pTemplate->InitialUpdateFrame(pFrame, pDocument);
CMultiDocTemplate* pDocTemplate;
	pDocTemplate = new CMultiDocTemplate(IDR_MyEditorTYPE,
		RUNTIME_CLASS(CMyEditorDoc),
		RUNTIME_CLASS(CChildFrame), // custom MDI child frame
		RUNTIME_CLASS(CMyEditorView));

MSDN曰:對於MFC中每個從CObject派生的類來說,都有一個相關的CRuntimeClass結構體,在程式執行時可以訪問該結構體來獲取物件及其基類的資訊。

CRuntimeClass是一個結構體,並且其本身並沒有基類。

在執行時確定一個物件的型別是很重要的,尤其是在做型別檢查時;而c++語言本身並不支援執行時類資訊。

CObject和CRuntimeClass是MFC中兩個非常重要的類/結構,絕大部分MFC類都是以CObject做為基類, CRuntimeClass結構同CObject密不可分,瞭解它們對於深入理解MFC具有重要意義。 
CRuntimeClass 的定義如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
struct CRuntimeClass
{
// Attributes
LPCSTR m_lpszClassName;     //類名,一般是指包含CRuntimeClass物件的類的名稱
int m_nObjectSize;              //包含CRuntimeClass物件的類sizeof的大小,不包括它分配的記憶體
UINT m_wSchema;              // schema number of the loaded class
CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class 指向一個建立例項的建構函式
 
#ifdef _AFXDLL
CRuntimeClass* (PASCAL* m_pfnGetBaseClass)();
#else
CRuntimeClass* m_pBaseClass; //m_pBaseClass的指標(函式)是MFC執行時確定類層次的關鍵,它一個簡單的單向連結串列
#endif
 
// Operations
 //這個函式給予CObject 派生類執行時動態建立的能力
CObject* CreateObject();
 
//這個函式使用 m_pBaseClass或 m_pfnGetBaseClass遍歷整個類層次確定是否pBaseClass指向的類是基類,
//使用它可以判斷某類是否是從pBaseClass指向的類在派生來。
BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;
 
// Implementation
void Store(CArchive& ar) const;
static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum);
 
// 單向連結串列,每個類的CRuntimeClass結構體物件的 m_pNextClass 都指向其直接基類的CRuntimeClass結構體物件
// 這一點可以在IMPLEMENT_RUNTIMECLASS 巨集定義中看到
CRuntimeClass* m_pNextClass; // linked list of registered classes
};

二、CObject類
CObject是MFC類的大多數類的基類,主要是通過它實現:
(1)、執行類資訊;(2)、序列化;(3)、物件診斷輸出;(4)、同集合類相相容;
(1)、執行時類資訊:
注意:要想使用CRuntimeClass結構得到執行時類資訊,你必須在你的類中包括DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC、 DECLARE_DYNCREATE/IMPLEMENT_DYNCREATE或DECLARE_SERIAL/IMPLEMENT_SERIAL。但你的類必須是從CObject派生的才能使用這些巨集, 因為通過DECLARE_DYNAMIC將定義一個實現如下的函式: 
CRuntimeClass* PASCAL B::_GetBaseClass()

return RUNTIME_CLASS(base_name); 
}

其中的RUNTIME_CLASS是這樣定義的

?
1
2
#define RUNTIME_CLASS( class_name ) \
(CRuntimeClass *)(&class_name::class##class_name);


即得到類中的CRuntimeClass物件指標,顯而易見,如果沒有基類你用IMPLEMENT_DYNAMIC時將得到一個編譯錯誤。 除非你象CObject一樣不用DECLARE_DYNAMIC而定義和實現了這些函式,CObject中的GetBaseClass只是簡單的返回NULL。 實際的DECLARE_DYNAMIC在afx.h中宣告如下:

?
1
2
3
4
5
6
7
8
#define DECLARE_DYNAMIC(classname) \
protected: \
static CRuntimeClass* PASCAL _GetBaseClass(); \
public: \
// 為使用DECLARE_DYNAMI巨集的類宣告一個靜態CRuntimeClass物件,並且指定其名字為“class” + “class_name”
//##class_name 在預處理階段會被自動翻譯為後面class_name
static const AFX_DATA CRuntimeClass class##class_name; \
virtual CRuntimeClass* GetRuntimeClass() const; \



IMPLEMENT_DYNAMIC在afx.h中定義如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL)
 
#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \
CRuntimeClass* PASCAL class_name::_GetBaseClass() \
{return RUNTIME_CLASS(base_class_name); } \
 
// 初始化類class_name的CRuntimeClass靜態變數,注意與CRuntimeClass結構體的定義對應觀察:
 
// 其m_pNextClass被賦值為&class_name::_GetBaseClass,而_GetBaseClass的定義如上,其直接返回
 
// 了基類的CRuntimeClass變數,這與上面對 m_pNextClass的解釋吻合。
AFX_COMDATconst AFX_DATADEF CRuntimeClass class_name::class##class_name = { \
#class_name, sizeof(class class_name), wSchema, pfnNew, \
&class_name::_GetBaseClass, NULL }; \
 
//重寫GetRuntimeClass虛擬函式,這個函式最初的定義在CObject中,重寫後,將返回子類自己的GetRuntimeClass變數
CRuntimeClass* class_name::GetRuntimeClass() const \
{return RUNTIME_CLASS(class_name); } \

總而言之,DECLARE_DYNAMIC(用於類的定義體中)與 IMPLEMENT_RUNTIMECLASS(用於類的實現檔案中)這兩個巨集,主要就是在預處理階段自動生成(更準確說應該是巨集翻譯轉換)用於類執行時檢查的函式和變數,主要包括獲取其基類的CRuntimeClass變數的函式_GetBaseClass,類本身的CRuntimeClass靜態變數定義,同時將類本身的CRuntimeClass靜態變數與其基類的CRuntimeClass靜態變數繫結起來,使得子類的該變數可以直接訪問到基類的變數,並且這種繫結是從子類到其基類遞迴進行的。在執行時判斷類資訊時,就可以通過類的CRuntimeClass靜態變數來進行對比,從而判斷出該類是否是相應的型別,這便是CObject中介面函式IsKindOf函式的作用,其實現類似於下面的過程:

?
1
2
3
4
5
6
BOOL CObject::IsKindOf(const CRuntimeClass *pClass) const
{
     CRuntimeClass *pClassThis = GetRuntimeClass();
     while (pClassThis != NULL)
     {
     // 檢查CRuntimeClass靜態變數是否相同,若相同,則表示所檢查的pClass是對的
?
1
2
3
4
5
6
7
8
      if (pClassThis == pClass)
         {
              return TRUE;
         }
         pClassThis = pClassThis->m_pBaseClass;
     }
     return FALSE;
}


其中的CRuntimeClass* GetRuntimeClass() const;被定義為虛擬函式,以完成在類層次上的過載。 這也是MFC利用多型實現執行時動態類資訊的方法。
另外兩個DECLARE_DYNCREATE和DECLARE_SERIAL類似。只不過它們多定義和實現了一些函式,對於使用DECLARE_DYNCREATE 要注意的是類必須要有一個無引數的預設建構函式,因為在DECLARE_DYNCREATE中定義了一個CreateObject函式 用以在動態的建立物件,它只是一條簡單的return new class_name。
我們先來看一下序列化:
,CObject實現這些功能絕大部分是通過它裡面的CRuntimeClass物件classObject實現的, 
CObject不支援多重繼承,即表示以CObject為基類的類層次中只能有一個CObject基類。

之所以會這樣,就是因為CRuntimeClass物件的成員m_pBaseClass的關係。因為它只是一個單連結串列。
以下是它在afx.h中的定義:

?
1
2
3
4
5
6
7
8
9
10
1
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/
// class CObject is the root of all compliant objects
 
#ifdef _AFXDLL
class CObject
#else
class AFX_NOVTABLE CObject
#endif
{
public:

 
// Object model (types, destruction, allocation)
 
virtual CRuntimeClass* GetRuntimeClass() const;
 
// 上面的函式的實現只是很簡單的return RUNTIME_CLASS(classObject);
 
virtual ~CObject();// virtual destructors are necessary
 
// Diagnostic allocations
void* PASCAL operator new(size_t nSize);
void* PASCAL operator new(size_t,void* p);
void PASCAL operator delete(void* p);
#if _MSC_VER >= 1200
void PASCAL operator delete(void* p, void* pPlace);
#endif
 
#if defined(_DEBUG) && !defined(_AFX_NO_DEBUG_CRT)
// for file name/line number tracking using DEBUG_NEW
void* PASCAL operator new(size_t nSize,LPCSTR lpszFileName,int nLine);
#if _MSC_VER >= 1200
void PASCAL operator delete(void *p,LPCSTR lpszFileName,int nLine);
#endif
#endif
 
// Disable the copy constructor and assignment by default so you will get
// compiler errors instead of unexpected behaviour if you pass objects
// by value or assign objects.
protected:
CObject();
private:
CObject(const CObject& objectSrc); // no implementation
void operator=(const CObject& objectSrc); // no implementation
 
// Attributes
public:
BOOL IsSerializable()const;// 對物件進行序列化
BOOL IsKindOf(const CRuntimeClass* pClass) const;//判是否是
 
// Overridables
virtual void Serialize(CArchive& ar);
 
#if defined(_DEBUG) || defined(_AFXDLL)
// Diagnostic Support
virtual void AssertValid()const;
virtual void Dump(CDumpContext& dc) const;
#endif
 
// Implementation
public:
static const AFX_DATA CRuntimeClass classCObject;
#ifdef _AFXDLL
static CRuntimeClass* PASCAL _GetBaseClass();
#endif
};