深入浅出 MFC Dynamic Creation 动态创建

MFC.H

#pragma  once
#define BOOL     int 
#define TRUE      1
#define FALSE     0
#define LPCSTR  LPSTR
typedef char*   LPSTR;
#define UINT    int

#define  PASCAL _stdcall
 

 class CObject;

struct CRuntimeClass
{
  //属性
	LPCSTR m_lpszClassName;
	int m_nObjectSize;
	UINT m_wSchema;


	//定义一个函数指针  动态创建 准备
	CObject *( PASCAL * m_pfnCreateObject)();


	CRuntimeClass *m_pBaseClass;

	
	static  CRuntimeClass * pFirstClass;
	CRuntimeClass *m_pNextClass;


	
	//创建函数
	CObject *CreateObject();

	//静态函数   
	static CRuntimeClass *  PASCAL Load();
	 

};

struct AFX_CLASSINIT
{
	//声明构造函数
	 AFX_CLASSINIT(CRuntimeClass *pNewClass);
};

//获取  CRuntimeClass  对象的地址
#define RUNTIME_CLASS(class_name) \
	(&class_name::class##class_name)

//为类class_name  1、声明一个CRuntimeClass 对象          2、返回该对象指针的一个函数GetRuntimeClass
#define DECLARE_DYANMIC(class_name)\
public:\
	static CRuntimeClass class##class_name;\
    virtual CRuntimeClass* GetRuntimeClass() const;


//1、给CRuntimeClass赋初值   2、定义函数GetRuntimeClass    3、声明  AFX_CLASSINIT结构体对象（不在类内部） 作用是实现 链接
#define  _IMPLEMENT_RUNTIMECLASS(class_name,base_class_name,wSchema,pfnNew) \
	static char _lpsz##class_name[]=#class_name;\
	CRuntimeClass class_name::class##class_name={  \
	_lpsz##class_name,sizeof(class_name),wSchema,pfnNew,\
	RUNTIME_CLASS(base_class_name),NULL};  \
	static AFX_CLASSINIT _init##class_name(&class_name::class##class_name); \
	CRuntimeClass* class_name::GetRuntimeClass() const \
	{return  &class_name::class##class_name;    } \


 //作用  初始化 CRuntimeClass 对象，并且加入链表
#define  IMPLEMENT_DYNAMIC(class_name,base_class_name) \
	_IMPLEMENT_RUNTIMECLASS(class_name,base_class_name,0xFFFF,NULL)



//增加了动态创建后，来实现这个
#define  DECLARE_DYNCREATE(class_name)\
	DECLARE_DYANMIC(class_name)   \
	static CObject * PASCAL CreateObject();

#define   IMPLEMENT_DYNCREATE(class_name,base_class_name)  \
	CObject  * PASCAL class_name::CreateObject()   \
           {  return new class_name;}  \
       _IMPLEMENT_RUNTIMECLASS(class_name,base_class_name,0xFFFF,class_name::CreateObject)



class CObject
{
 
public:
	virtual CRuntimeClass * GetRuntimeClass()const;
	static  CRuntimeClass  classCObject;
	BOOL IsKindOf(const CRuntimeClass *pClass) const;
	virtual void SayHello();
};

class CCmdTarget:public CObject
{
public:
	DECLARE_DYANMIC(CCmdTarget);   //相当于定义一个  CRuntimeCLass   对象 和一个函数
};

class CWinThread:public CCmdTarget
{
	DECLARE_DYANMIC(CWinThread);
public:
	virtual BOOL InitInstance();
	virtual int Run();
};

class CWnd;
class CWinApp:public CWinThread
{
	DECLARE_DYANMIC(CWinApp);
public:
	CWinApp * m_pCurrentWinApp;
	CWnd   *  m_pMainWnd;
public:
	CWinApp();
	virtual BOOL InitApplication();
	virtual BOOL InitInstance();
	virtual int Run();
};
class CDocument:public CCmdTarget
{
	DECLARE_DYANMIC(CDocument);
public:
	
};

class CWnd:public CCmdTarget
{
	DECLARE_DYNCREATE(CWnd);
public:
	CWnd();
	void SayHello();
	virtual BOOL Create();
	BOOL CreateEx();
	virtual BOOL PreCreateWindow();
};

class CFrameWnd:public CWnd
{
	DECLARE_DYNCREATE(CFrameWnd);
public:
	CFrameWnd();
	BOOL Create();
	virtual BOOL PreCreateWindow();
};
 
class CView:public CWnd
{
public:
	CView();
	void SayHello();
	DECLARE_DYNCREATE(CView);

};


CWinApp *AfxGetApp();

MFC.CPP

#include "stdafx.h"
#include "MFC.h"
#include "MY.h"
#include <iostream>
using namespace std;
//公共函数定义
CRuntimeClass*  CRuntimeClass::pFirstClass=NULL;

//定义构造函数
AFX_CLASSINIT::AFX_CLASSINIT(CRuntimeClass *pNewClass)
{
   pNewClass->m_pNextClass=CRuntimeClass::pFirstClass;
   CRuntimeClass::pFirstClass=pNewClass;
}


//初始化 CObject

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


//返回 新创建的类指针
CObject *CRuntimeClass::CreateObject()
{
	if (m_pfnCreateObject==NULL)
	{
		 
 
		return NULL;
	}

	CObject *pObject=NULL;
	pObject=(*m_pfnCreateObject)();
	return pObject;
}


//输入 类名，返回该类名的 CRuntimeClass
CRuntimeClass *PASCAL CRuntimeClass::Load()
{
	char szClassName[64];
	CRuntimeClass *pClass;
	cout<<"Enter a class name... ";
	cin>>szClassName;

	for (pClass=pFirstClass;pClass!=NULL;pClass=pClass->m_pNextClass)
	{
		if (strcmp(szClassName,pClass->m_lpszClassName)==0)
		{
			return pClass;
		}
	}

	return NULL;


}

BOOL CObject::IsKindOf(const CRuntimeClass *pClass) const
{
	CRuntimeClass *pClassThis=GetRuntimeClass();
	while(pClassThis)
	{
		if (pClassThis==pClass)
		{
			return true;
		}
		pClassThis=pClassThis->m_pBaseClass;
	}

	return false;
}
void  CObject::SayHello()
{
	cout<<"Hello  CObject"<<endl;
}

static char szObject[]="classCObject";
 CRuntimeClass  CObject::classCObject=
{szObject,sizeof(CObject),0xffff,NULL,NULL,NULL};
 


//定义该结构体对象
static AFX_CLASSINIT  _init_CObject(&CObject::classCObject);



 BOOL CWinThread::InitInstance()
{
	cout<<"CWinThread::InitInstance"<<endl;
	return TRUE;
}
 int CWinThread::Run()
{
	cout<<"CWinThread::Run"<<endl;
	return 1;
}


CWinApp::CWinApp()
{
	m_pCurrentWinApp=this;
}
 BOOL CWinApp::InitApplication()
{
	cout<<"CWinApp::InitApplication"<<endl;
	return TRUE;
}
 BOOL CWinApp::InitInstance()
{
	cout<<"CWinApp::InitInstance"<<endl;
	return CWinThread::InitInstance();
}
 int CWinApp::Run()
{
	cout<<"CWinApp::Run"<<endl;
	return CWinThread::Run();
}


 BOOL CWnd::Create()
{
	cout<<"CWnd::Create()"<<endl;
	return TRUE;
}
 void CWnd::SayHello()
 {
	 cout<<"Hello   CWnd"<<endl;
 }
 CWnd::CWnd()
 {
	 cout<<"CWnd Constructor"<<endl;
 }

BOOL CWnd::CreateEx()
{
	PreCreateWindow();
	return TRUE;
}
 BOOL CWnd::PreCreateWindow()
{
	return TRUE;
}


 CFrameWnd::CFrameWnd()
 {
	 cout<<"CFrameWnd  Constructor"<<endl;
 }
BOOL CFrameWnd::Create()
{
	CreateEx();
	return TRUE;
}
 BOOL CFrameWnd::PreCreateWindow()
{
	cout<<"CFrameWnd::PreCreateWindow"<<endl;
	return TRUE;
}

 CView::CView()
 {
	 cout<<"CView Constructor"<<endl;
 }
 void CView::SayHello()
 {
	 cout<<"Hello CView"<<endl;
 }

 IMPLEMENT_DYNAMIC(CCmdTarget,CObject);
 IMPLEMENT_DYNAMIC(CWinThread,CCmdTarget);
 IMPLEMENT_DYNAMIC(CWinApp,CWinThread);

 IMPLEMENT_DYNAMIC(CDocument,CCmdTarget);
 

 IMPLEMENT_DYNCREATE(CWnd,CCmdTarget);
 IMPLEMENT_DYNCREATE(CFrameWnd,CWnd);


 IMPLEMENT_DYNAMIC(CView,CWnd);



 extern CMyWinApp theApp;
 CWinApp *AfxGetApp()
 {
	 return theApp.m_pCurrentWinApp;
 }

MY.H

#pragma  once

#include <iostream>
using namespace std;

#include "MFC.h"
class CMyWinApp:public CWinApp
{
public:
	virtual BOOL  InitInstance();
};

class CMyFrameWnd:public CFrameWnd
{
public:
		void SayHello();
	CMyFrameWnd();

   DECLARE_DYNCREATE(CMyFrameWnd);
  
};
class CMyDoc:public CDocument
{
public:
	void SayHello();
	DECLARE_DYNCREATE(CMyDoc);
};
class CMyView:public CView
{
  public:
     void SayHello();
	DECLARE_DYNCREATE(CMyView);
};

MY.CPP

#include "stdafx.h"
#include "MY.h"
#include "MFC.h"


BOOL  CMyWinApp::InitInstance()
{
	m_pMainWnd=new CFrameWnd;
	return TRUE;
}

CMyFrameWnd::CMyFrameWnd()
{
	cout<<"CMyFrameWnd Constructor"<<endl;
	Create();
}
void CMyFrameWnd::SayHello()
{
	cout<<"Hello CMyFrameWnd"<<endl;
}

void CMyDoc::SayHello()
{
	cout<<"Hello  CMyDoc"<<endl;
}
void CMyView::SayHello()
{
	cout<<"Hello CView"<<endl;
}
IMPLEMENT_DYNCREATE(CMyDoc,CDocument);
IMPLEMENT_DYNCREATE(CMyFrameWnd,CFrameWnd);
IMPLEMENT_DYNCREATE(CMyView,CView);

 
 
CMyWinApp  theApp;

MAIN.CPP

// Frame3.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdlib.h>
#include "MY.h"

void printAllClasses()
{
	CRuntimeClass *pFirst=NULL;
	for (pFirst=CRuntimeClass::pFirstClass;pFirst;pFirst=pFirst->m_pNextClass)
	{
		cout<<"名字："<<pFirst->m_lpszClassName;
		cout<<"    大小："<<pFirst->m_nObjectSize<<endl;
	}
}
int _tmain(int argc, _TCHAR* argv[])
{

	CWinApp *pApp=AfxGetApp();
	pApp->InitApplication();
	pApp->InitInstance();
	pApp->Run();

	printAllClasses();



	//CMyDoc *pDoc=new CMyDoc();
	//CMyView *pView=new CMyView();

	//cout<<pDoc->IsKindOf(RUNTIME_CLASS(CMyDoc))<<endl;
	//cout<<pDoc->IsKindOf(RUNTIME_CLASS(CDocument))<<endl;
	//cout<<pDoc->IsKindOf(RUNTIME_CLASS(CCmdTarget))<<endl;
	//cout<<pDoc->IsKindOf(RUNTIME_CLASS(CWinApp))<<endl;

	//cout<<pDoc->IsKindOf(RUNTIME_CLASS(CView))<<endl;


	//cout<<pView->IsKindOf(RUNTIME_CLASS(CView))<<endl;
	//cout<<pView->IsKindOf(RUNTIME_CLASS(CObject))<<endl;
	//cout<<pView->IsKindOf(RUNTIME_CLASS(CWnd))<<endl;
	//cout<<pView->IsKindOf(RUNTIME_CLASS(CFrameWnd))<<endl;

	CRuntimeClass *pClassRef;
	CObject *pOb;
	while(1)
	{
		if ((pClassRef=CRuntimeClass::Load())==NULL)
		{
			break;
		}
		pOb=pClassRef->CreateObject();
		if (pOb!=NULL)
		{
			pOb->SayHello();
		}
	}


	system("pause");
	return 0;
}