Why in Doc/view classes are created dynamically?

Frame window

MFC frame base aplication or dialog base application creates a frame window by directly with new operator. Main window is assigned to a base i.e. class CWnd pointer and framework takes care rest of the things.

virtual BOOL InitInstance()
{
  m_pMainWnd = new CMyWnd();
  m_pMainWnd->ShowWindow(SW_SHOW);
  m_pMainWnd->UpdateWindow();
  return TRUE;
}

DOC/VIEW objects

Doc view application never creates a DOC, VIEW and FRAME object directly with new operator. Here framework takes runtime pointer RUNTIME_CLASS.

	CSingleDocTemplate* pDocTemplate;
	pDocTemplate = new CSingleDocTemplate(
		IDR_MAINFRAME,
		RUNTIME_CLASS(CMySDIDoc),
		RUNTIME_CLASS(CMainFrame),
		RUNTIME_CLASS(CMySDIView));
	AddDocTemplate(pDocTemplate);

CSingleDocTemplate constructor

Runtime class pointers are validated in runtime and saved in member variables in CDocTemplate.

	CDocTemplate::CDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass,
	CRuntimeClass* pFrameClass, CRuntimeClass* pViewClass)
{
	ASSERT_VALID_IDR(nIDResource);
	ASSERT(pDocClass == NULL ||
		pDocClass->IsDerivedFrom(RUNTIME_CLASS(CDocument)));
	ASSERT(pFrameClass == NULL ||
		pFrameClass->IsDerivedFrom(RUNTIME_CLASS(CFrameWnd)));
	ASSERT(pViewClass == NULL ||
		pViewClass->IsDerivedFrom(RUNTIME_CLASS(CView)));
	m_pDocClass = pDocClass;
	m_pFrameClass = pFrameClass;
	m_pViewClass = pViewClass;

}

CreateNewDocument call stack

Framework calls CreateNewDocument at New document event.

CMySDIDoc::CMySDIDoc()
CMySDIDoc::CreateObject()
CRuntimeClass::CreateObject()
CDocTemplate::CreateNewDocument()
CSingleDocTemplate::OpenDocumentFile()
CDocManager::OnFileNew()

CDocTemplate::CreateNewDocument

RUNTIME class is casted to base pointer i.e. CDocument and CreateObject() is called. CreateObject() function calls m_pfnCreateObject function pointer.


CDocument* CDocTemplate::CreateNewDocument()
{
	// default implementation constructs one from CRuntimeClass
	if (m_pDocClass == NULL)
	{
		TRACE0("Error: you must override CDocTemplate::CreateNewDocument.\n");
		ASSERT(FALSE);
		return NULL;
	}
	CDocument* pDocument = (CDocument*)m_pDocClass->CreateObject();
	
}

CRuntimeClass::CreateObject

CRuntimeClass uses base abstruct class CObject and calls function pointer which eventually calls the derived class CreateObject.

CObject* CRuntimeClass::CreateObject()
{
	if (m_pfnCreateObject == NULL)
	{
		TRACE(_T("Error: Trying to create object which is not ")
			  _T("DECLARE_DYNCREATE \nor DECLARE_SERIAL: %hs.\n"),
			m_lpszClassName);
		return NULL;
	}

	CObject* pObject = NULL;
	TRY
	{
		pObject = (*m_pfnCreateObject)();
	}
	END_TRY

	return pObject;
}

CreateObject and new call

Derived class implements this CreateObject() and calls new operator. CMySDIDoc defines our CreateObject() with IMPLEMENT_DYNCREATE() macro and thus new operator calls the constructor CMySDIDoc().

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

Thus creation of DOC, View and Frame are all at runtime with dynamic function pointer. This RUNTIME class and DECLARE_DYNCREATE & IMPLEMENT_DYNCREATE makes all things.

About our authors: Team EQA