DECLARE_DYNCREATE：支持动态创建
DECLARE_DYNAMIC：支持运行时类型识别（RTTI）
凡是支持动态创建的，一定支持RTTI。
#define DECLARE_DYNCREATE(class_name) DECLARE_DYNAMIC(class_name) static CObject* PASCAL CreateObject(); #define DECLARE_DYNAMIC(class_name) protected: static CRuntimeClass* PASCAL _GetBaseClass(); public: static const CRuntimeClass class##class_name; static CRuntimeClass* PASCAL GetThisClass(); virtual CRuntimeClass* GetRuntimeClass() const;
#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, NULL) #define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew, class_init) CRuntimeClass* PASCAL class_name::_GetBaseClass() { return RUNTIME_CLASS(base_class_name); } AFX_COMDAT const CRuntimeClass class_name::class##class_name = { #class_name, sizeof(class class_name), wSchema, pfnNew, &class_name::_GetBaseClass, NULL, class_init }; //注：函数名就是地址，即 &func == func CRuntimeClass* PASCAL class_name::GetThisClass() { return _RUNTIME_CLASS(class_name); } CRuntimeClass* class_name::GetRuntimeClass() const { return _RUNTIME_CLASS(class_name); } #define RUNTIME_CLASS(class_name) (class_name::GetThisClass()) #define _RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name))
所以：
// MainFrm.h DECLARE_DYNCREATE(CMainFrame) 翻译为 DECLARE_DYNAMIC(CMainFrame) static CObject* PASCAL CreateObject(); 最终翻译为 protected: static CRuntimeClass* PASCAL _GetBaseClass(); public: static const CRuntimeClass classCMainFrame; static CRuntimeClass* PASCAL GetThisClass(); virtual CRuntimeClass* GetRuntimeClass() const; static CObject* PASCAL CreateObject(); // MainFrm.cpp IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd) 翻译为 CObject* PASCAL CMainFrame::CreateObject() { return new CMainFrame; } IMPLEMENT_RUNTIMECLASS(CMainFrame, CFrameWnd, 0xFFFF, CMainFrame::CreateObject, NULL) 最终翻译为 CObject* PASCAL CMainFrame::CreateObject() { return new CMainFrame; } CRuntimeClass* PASCAL CMainFrame::_GetBaseClass() { return CFrameWnd::GetThisClass(); } // return (CRuntimeClass*)(&CFrameWnd::classCMainFrame)； AFX_COMDAT const CRuntimeClass CMainFrame::classCMainFrame= { "CMainFrame", sizeof(class MainFrame), 0xFFFF, CMainFrame::CreateObject, &CMainFrame::_GetBaseClass, NULL, NULL }; CRuntimeClass* PASCAL CMainFrame::GetThisClass() { return (CRuntimeClass*)(&CMainFrame::classCMainFrame); } CRuntimeClass* CMainFrame::GetRuntimeClass() const { return (CRuntimeClass*)(&CMainFrame::classCMainFrame); }
CRuntimeClass类的定义
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; // dynamic name lookup and creation static CRuntimeClass* PASCAL FromName(LPCSTR lpszClassName); static CRuntimeClass* PASCAL FromName(LPCWSTR lpszClassName); static CObject* PASCAL CreateObject(LPCSTR lpszClassName); static CObject* PASCAL CreateObject(LPCWSTR lpszClassName); // 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 const AFX_CLASSINIT* m_pClassInit; };
可以看出：主要是一个静态成员变量，和四个成员函数。
静态成员变量classCMainFrame 主要是用于存储本类的信息和基类的信息地址。
GetRuntimeClass()：用于获取本类信息地址，即 &classCMainFrame （GetRuntimeClass()等于GetThisClass() ）。
_GetBaseClass：用于获取基类信息的地址，即 &CFrameWnd::classCMainFrame
静态成员函数 CreateObject() ：用于在堆空间申请对象空间。
宏定义中 #：表示字符串 ##：表示连接
在用#define 定义时 , 斜杠("")是用来续行的，
"#"用来把参数转换成字符串，是给参数加上双引号。
"##"则用来连接前后两个参数，把它们变成一个参数,
"#@"是给参数加上单引号。下面的例子会使您很容易理解。
#define CAT(x,y) x##y /* CAT("1","abc") => "1abc" CAT(1, 34) => 134 */
#define TOCHAR(a) #@a /* TOCHAR(1) => '1' */
#define TOSTRING(x) #x /* TOSTRING(1) => "1" */
参考： https://blog.csdn.net/biblereader/article/details/988100
本来,在C/C++中有一个typeid操作符(类似于sizeof),它可以判断对象的类型,用法如下:
Devi objDevi; //Devi是本人自定义的一个类;
if (typeid(Devi)==typeid(objDevi))
{
cout<<"objDevi is a object of class Devi"<<endl;
}
const type_info& tpdevi=typeid(objDevi);
cout<<tpdevi.name()<<endl; //这里得出是class Devi的类型,用于人识别
cout<<tpdevi.raw_name()<<endl; //这里返回的是内存表示,用于计算机识别
可惜的是typeid比MFC的RTTI晚出现, MFC中的RTTI没有使用typeid,而是用了上面提到的一系列的宏,什么要求用什么宏,MSDN同样有说明:
Macros Used for Serialization and Run-Time Information
| Macro used | CObject::IsKindOf | CRuntimeClass::CreateObject | CArchive::operator>> CArchive::operator<< |
| Basic CObject functionality | No | No | No |
| DECLARE_DYNAMIC | Yes | No | No |
| DECLARE_DYNCREATE | Yes | Yes | No |
| DECLARE_SERIAL | Yes | Yes | Yes |
仅判断类型,用DECLARE_DYNAMIC足矣, 要动态创建对象,得用 DECLARE_DYNCREATE, 而如果要串行化,则得用 DECLARE_SERIAL宏.
每个从CObject派生来的类都有一个CRuntimeClass* GetRuntimeClass( ) const函数,用来返回一个CRuntimeClass对象。如何在各个类之中插入CRuntimeClass对象，并且指定CRuntimeClass对象的内容及CRuntimeClass对象的链接？MFC用了两个宏实现了这些工作，即DECLARE_DYNAMIC(类名)和IMPLEMENT_DYNAMIC(类名，基类名)。
而CObject的另一个函数IsKindOf被用来进行运行时识别工作,自从有了IsKindOf,生活就变得美好了:
BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const { CRuntimeClass* pClassThis = GetRuntimeClass();//GetRuntimeClass()是个虚函数，每个从CObject继承的类，并使用了宏DECLARE_DYNAMIC ，都重写了GetRuntimeClass()，根据多态，调用子类中的 GetRuntimeClass()，即返回子类的类信息的地址 (&class***) return pClassThis->IsDerivedFrom(pClass); }
而GetRuntimeClass()的作用是返回与该类关联的CRuntimeClass类指针:
CRuntimeClass* CObject::GetRuntimeClass() const { return _RUNTIME_CLASS(CObject);// 即 静态成员的地址 &class*** }
而这个宏RUNTIME_CLASS 就是用来得到一个static const AFX_DATA CRuntimeClass classCObject. (每个从CObject派生的类如CMainFrame都有成员classCMainFrame,这个class***成员就是与MFC类相关的那个CRuntimeClass对象!!).
解决问题的关键还在于上面的IsDerivedFrom函数:
BOOL CRuntimeClass::IsDerivedFrom(const CRuntimeClass* pBaseClass) const { const CRuntimeClass* pClassThis = this; while (pClassThis != NULL) { if (pClassThis == pBaseClass) return TRUE; //从pBaseClass派生则返回,否则继续循环,万一不行,则返回FALSE; pClassThis = pClassThis->m_pBaseClass; } return FALSE; // walked to the top, no match }
从宏观上说,IsKindOf函数判断了一个MFC对象(而不是类)的类型!!
结论: 如果你的类派生自CObject且使用了 DECLARE_DYNAMIC and IMPLEMENT_DYNAMIC宏,那么,你的类就能够调用IsKindOf方法, 而如果调用IsKindOf方法, 则能够获取该类的类型信息(如果不调用IsKindOf函数,自然也就没从获取类型信息了).
例如：
BOOL b = pObject->IsKindOf(RUNTIME_CLASS());
MFC的动态创建过程:
1、定义一个不带参数的构造函数,因为我们是用CreateObject()动态创建，它只有一条语句就是 return new XXX，不带任何参数。
2、类说明中使用DECLARE_DYNCREATE（CLASSNMAE）宏；和在类的实现文件中使用IMPLEMENT_DYNCREATE（CLASSNAME，BASECLASS）宏,这个宏完成构造CRuntimeClass对象，并加入到链表中。
3、使用时先通过宏RUNTIME_CLASS得到类的RunTime信息，然后使用CRuntimeClass的成员函数CreateObject创建一个该类的实例。
4、CObject* pObject = pRuntimeClass->CreateObject();//完成动态创建
总结: MFC动态创建的最终动作是CRuntimeClass::CreateObject();获得类型信息只是过程的一环.
例如：
CRunTimeClass* prt = RUNTIMR_CLASS(CMyFrame);//CMyFrame是自己创建的继承CMIniFrame的MFC类，会自动添加DECLARE_DYNCREATE等宏 m_pFrame = (CMyFrame*)prt->CreateObject();//或者 m_pFrame = DYNAMIC_DOWNCASE(CMyFrame, prt->CreateObject()); 实际就是new XXX；但不用自己delete
可简单地理解为 DECLARE_DYNCREATE 宏是 DECLARE_DYNAMIC 宏与 CreateObject函数的合, DECLARE_SERIAL 是 DECLARE_DYNCREATE 与操作符operator>>的合. 这里的operator>>是IMPLEMENT_SERIAL宏重载的.因此,MSDN中也看到了,要使一个类可串行化,使用DECLARE_SERIAL和IMPLEMENT_SERIAL宏只是一步而已,还要重载Serialize等工作.
总结: 看CRuntimeClass的源代码知道,CRuntimeClass还有两个函数Load和Store,这两个函数的实现中还调用了CArchive的Read和Write方法,但是要说明的是,CRuntimeClass的Load/Store在文件的串行化中,只是做了一些辅助工作,如判断是否第一次出现,记录版本号,记录文件名等,真正实现串行化的还是CArchive的operator<</operator>>以及其他一些方法.
CRuntimeClass对象只是MFC类的一个成员变量,它记录了本MFC类的一些信息,帮助本MFC类实现一些功能,仅此而已.
***********