深入浅出MFC---Frame3

struct CRuntimeClass
{
// Attributes
LPCSTR m_lpszClassName;
int m_nObjectSize;
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;
#endif

// Operations
CObject* CreateObject();
BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;

// Implementation
void Store(CArchive& ar) const;
static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum);

// CRuntimeClass objects linked together in simple list
CRuntimeClass* m_pNextClass;       // linked list of registered classes
};

/////////////////////////////////////////////
#define DECLARE_DYNAMIC(class_name) \
public: \
static const AFX_DATA CRuntimeClass class##class_name; \
virtual CRuntimeClass* GetRuntimeClass() const; \

///////////////////////////////////////////////
#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) \
AFX_COMDAT const AFX_DATADEF CRuntimeClass class_name::class##class_name = { \
#class_name, sizeof(class class_name), wSchema, pfnNew, \
RUNTIME_CLASS(base_class_name), NULL }; \
CRuntimeClass* class_name::GetRuntimeClass() const \
{ return RUNTIME_CLASS(class_name); } \

#include <stdio.h>
#include <windows.h>
class CObject;
class CArchive;

struct CRuntimeClass
{
// Attributes
LPCSTR m_lpszClassName;
int m_nObjectSize;
UINT m_wSchema; // schema number of the loaded class
CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class

CRuntimeClass* m_pBaseClass;
// Operations
CObject* CreateObject();
BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;

// Implementation
void Store(CArchive& ar) const;
static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum);

// CRuntimeClass objects linked together in simple list
CRuntimeClass* m_pNextClass;       // linked list of registered classes
};

#define AFX_DATA
#define AFX_COMDAT
#define AFX_DATADEF

#define DECLARE_DYNAMIC(class_name) \
public: \
static const AFX_DATA CRuntimeClass class##class_name; \
virtual CRuntimeClass* GetRuntimeClass() const; \

#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \
AFX_COMDAT const AFX_DATADEF CRuntimeClass class_name::class##class_name = { \
#class_name, sizeof(class class_name), wSchema, pfnNew, \
RUNTIME_CLASS(base_class_name), NULL }; \
CRuntimeClass* class_name::GetRuntimeClass() const \
{ return RUNTIME_CLASS(class_name); } \

#define RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name))

#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL)

class CObject
{
public:
CObject()
{
}
~CObject()
{
}
static AFX_DATA const CRuntimeClass classCObject;
virtual CRuntimeClass* GetRuntimeClass() const;
BOOL IsKindOf(const CRuntimeClass* pClass)
{
CRuntimeClass *pClassThis = GetRuntimeClass();
while(pClassThis!=NULL)
{
if(pClassThis == pClass)
return TRUE;
pClassThis = pClassThis->m_pBaseClass;
}
return FALSE;
}
};

const CRuntimeClass CObject::classCObject={"CObject",sizeof(class CObject),0xffff,NULL,NULL,NULL};

CRuntimeClass *CObject::GetRuntimeClass() const
{
return (CRuntimeClass*)&(CObject::classCObject);
}

class CCmdTarget:public CObject
{
DECLARE_DYNAMIC(CCmdTarget)
public:
CCmdTarget()
{
}
~CCmdTarget()
{
}
};
IMPLEMENT_DYNAMIC(CCmdTarget,CObject)

class CWinThread:public CCmdTarget
{
DECLARE_DYNAMIC(CWinThread)
public:
CWinThread()
{
}
~CWinThread()
{
}
public:
virtual void InitInstance()
{
printf("CWinThread InitInstance\n");
}
virtual void Run()
{
printf("CWinThread Run\n");
}
};
IMPLEMENT_DYNAMIC(CWinThread,CCmdTarget)

class CWnd;

class CWinApp:public CWinThread
{
DECLARE_DYNAMIC(CWinApp)
public:
CWinApp    *m_pCurrentWinApp;
CWinThread *m_pCurrentWinThread;
CWnd       *m_pMainWnd;
public:
CWinApp()
{
m_pCurrentWinApp = this;
m_pCurrentWinThread = this;
}
~CWinApp()
{
}
public:
virtual void InitApplication()
{
printf("CWinApp InitApplication \n");
}
virtual void InitInstance()
{
printf("CWinApp InitInstance \n");
}
virtual void Run()
{
printf("CWinApp Run\n");
CWinThread::Run();
}

};
IMPLEMENT_DYNAMIC(CWinApp,CWinThread)

class CDocument :public CCmdTarget
{
DECLARE_DYNAMIC(CDocument)
public:
CDocument()
{
}
~CDocument()
{
}
};
IMPLEMENT_DYNAMIC(CDocument,CCmdTarget)

class CWnd:public CCmdTarget
{
DECLARE_DYNAMIC(CWnd)
public:
CWnd()
{
}
~CWnd()
{
}
public:
virtual void PreCreateWindow()
{
printf("CWnd PreCreateWindow \n");
}
virtual void Create()
{
printf("CWnd Create \n");
}
void CreateEx()
{
printf("CWnd CreateEx\n");
PreCreateWindow();
}
friend class CWinApp;
};
IMPLEMENT_DYNAMIC(CWnd,CCmdTarget)

class CFrameWnd:public CWnd
{
DECLARE_DYNAMIC(CFrameWnd)
public:
CFrameWnd()
{
}
~CFrameWnd()
{
}
public:
virtual void Create()
{
printf("CFrameWnd Create \n");
CreateEx();
}
virtual void PreCreateWindow()
{
printf("CFrameWnd PreCreateWindow \n");
}
};
IMPLEMENT_DYNAMIC(CFrameWnd,CWnd)

class CView:public CWnd
{
DECLARE_DYNAMIC(CView)
public:
CView()
{
}
~CView()
{
}
};
IMPLEMENT_DYNAMIC(CView,CWnd)

//////////////////////////////////////////////////////////////////////////

class CMyFrameWnd:public CFrameWnd
{
DECLARE_DYNAMIC(CMyFrameWnd , CFrameWnd)
public:
CMyFrameWnd()
{
Create();
}
~CMyFrameWnd()
{
}
};
IMPLEMENT_DYNAMIC(CMyFrameWnd , CFrameWnd)

class CMyWinApp:public CWinApp
{
public:
CMyWinApp()
{
}
~CMyWinApp()
{
}
public:
void InitInstance()
{
printf("CMyWinApp InitInstance \n");
m_pMainWnd = new CMyFrameWnd;
}
};

CMyWinApp theApp;

//////////////////////////////////////////////////////////////////////////
CWinApp *AfxGetApp()
{
return theApp.m_pCurrentWinApp;
}
CWinThread *AfxGetThread()
{
return theApp.m_pCurrentWinThread;
}

void PrintAllClasses()
{
CRuntimeClass *pClass;
for(pClass = (CRuntimeClass*)&CObject::classCObject;pClass!=NULL;pClass=pClass->m_pNextClass)
{
printf("%s\n",pClass->m_lpszClassName);
}
}

void main()
{
CWinThread* pThread = AfxGetThread();
CWinApp* pApp = AfxGetApp();

pApp->InitApplication();

pThread->InitInstance();
pThread->Run();

PrintAllClasses();

CMyFrameWnd Wnd;
CRuntimeClass *pClass = Wnd.GetRuntimeClass();
for(;pClass!=NULL;pClass = pClass->m_pBaseClass)
{
printf("m_lpszClassName:%s\nm_nObjectSize:%d\nm_wSchema:%d\n" \
,pClass->m_lpszClassName,pClass->m_nObjectSize,pClass->m_wSchema);
}

CWinApp App;
pClass = App.GetRuntimeClass();
printf("m_lpszClassName:%s\nm_nObjectSize:%d\nm_wSchema:%d\n" \
,pClass->m_lpszClassName,pClass->m_nObjectSize,pClass->m_wSchema);

//	CMyFrameWnd MyWnd;
//	CFrameWnd   Frame;
if(Wnd.IsKindOf(RUNTIME_CLASS(CCmdTarget)))
{
printf("Yes\n");
}

}