深入浅出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");
	}

}