MFC的运行时类型识别(RTTI)

系统管理员 2023-01-02 08:20 148阅读 0赞

虽然之前使用过MFC，但是仅仅处在了一种“知其皮，而不知其骨”的状态，所以打算趁这段时间再把侯捷老师的《深入浅出MFC》学习一番\*~\*。

### 文章目录 ###

*  一、简介
 *  二、模拟MFC中的RTTI
 *  三、小结

# 一、简介 #

> 简单的来讲运行时类型识别（RTTI）即是在程序运行的过程中实现对对象类型的识别，因为在大多数情况下，程序中的对象等都是在编译时就已知该对象的数据类型，所以要实现运行时对象类型识别则就需要花费一番心思。

# 二、模拟MFC中的RTTI #

跟着书中的思路，其实我们可以很容易就理解其实现的机制：就是建立一张类别型录表（单向链表，不过存在两个表：同宗与非同宗），然后通过遍历链表中的所有节点元素来判断某一对象的类别。代码实现的过程如下所示：

> MFC.h

#ifndef MFC_H
    #define MFC_H
    
    #define LPCSTR LPSTR
    typedef char* LPSTR;
    #define UINT int
    #define PASCAL _stdcall
    
    #include<iostream>
    using namespace std;
    
    class CObject;	//在使用类型之前，要有类型的定义
    
    struct CRuntimeClass		//类别链表的节点类型
    { 
    	//属性
    	LPSTR m_lpszClassName;		//类型名
    	int m_nObjectSize;			//类型大小
    	UINT m_wSchema;		//加载类的计划数？？？,没有理解
    	CObject* (PASCAL* m_pfnCreateObject)();		//NULL->抽象类
    	CRuntimeClass* m_pBaseClass;	//父类节点（同宗）
    
    	//使用一个简单的链表来链接CRuntimeClass对象
    	static CRuntimeClass* pFirstClass;	//CRuntimeClass链表的起点
    	CRuntimeClass* m_pNextClass;		//链表中的下一个CRuntimeClass对象（不一定同宗），这与下面添加节点元素（IMPLEMENT_DYNAMIC）的顺序有关
    };
    
    struct AFX_CLASSINIT
    { 
    	AFX_CLASSINIT(CRuntimeClass* pNewClass);
    };
    
    //
    //实现RTTI的宏定义
    //
    #define RUNTIME_CLASS(class_name)\ (&class_name::class##class_name)
    
    //其实也就是一个类别的节点和一个获取类别的函数
    #define DECLARE_DYNAMIC(class_name)\ public:\ static CRuntimeClass class##class_name;\ virtual CRuntimeClass* GetRuntimeClass() const;
    
    #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;}\ 
    #define IMPLEMENT_DYNAMIC(class_name,base_class_name)\ _IMPLEMENT_RUNTIMECLASS(class_name,base_class_name,0xFFFF,NULL)
    	
    
    class CObject { 
    public:
    	CObject() {  
    		//cout << "CObject被构建！ \n"; 
    	};
    	~CObject() {  
    		//cout << "CObject被销毁！ \n"; 
    	};
    
    	virtual CRuntimeClass* GetRuntimeClass() const;
    	bool IsKindOf(const CRuntimeClass* pClass) const;
    public:
    	static CRuntimeClass classCObject;			//这其实就是类别型录表的一个节点
    };
    
    class CCmdTarget : public CObject
    { 
    	DECLARE_DYNAMIC(CCmdTarget);		//添加一个类别的节点和一个获取类别的函数
    public:
    	CCmdTarget::CCmdTarget() { 
    		//cout << "CCmdTarget 被构建！ \n";
    	}
    	CCmdTarget::~CCmdTarget() { 
    		//cout << "CCmdTarget 被销毁！ \n";
    	}
    };
    
    class CWinThread : public CCmdTarget
    { 
    	DECLARE_DYNAMIC(CWinThread);
    public:
    	CWinThread::CWinThread() { 
    		//cout << "CWinThread 被构建！ \n";
    	}
    	CWinThread::~CWinThread() { 
    		//cout << "CWinThread 被销毁！ \n";
    	}
    
    	//虚函数的妙用，实现了不同对象的实例化
    	virtual bool InitInstance() { 
    		cout << "CWinThread::InitInstance\n";
    		return true;
    	}
    
    	virtual int Run() { 
    		cout << "CWinTread::Run\n";
    		return 1;
    	}
    };
    
    class CWnd;
    
    class CWinApp : public CWinThread
    { 
    	DECLARE_DYNAMIC(CWinApp);
    public:
    	CWinApp* m_pCurrentWinApp;		//定义局部变量
    	CWnd* m_pMainWnd;
    
    public:
    	CWinApp::CWinApp() { 
    		//cout << "CWinApp 被构建！ \n";
    		m_pCurrentWinApp = this;		//进行构造的时候把对象赋给m_pCurrentWinApp
    	}
    	CWinApp::~CWinApp() { 
    		//cout << "CWinApp 被销毁！ \n";
    	}
    
    	//虚函数的妙用，实现了不同对象的实例化
    	virtual bool InitInstance() { 
    		cout << "CWinApp::InitInstance\n";
    		return true;
    	}
    
    	virtual int Run() { 			//该对象运行的时候也会使得其父类也运行
    		cout << "CWinApp::Run\n";
    		return CWinThread::Run();
    	}
    
    	virtual bool InitApplication() { 		//每个程序只做一次的操作
    		cout << "CWinApp::InitApplication\n";
    		return true;
    	}
    };
    
    class CDocument : public CCmdTarget
    { 
    	DECLARE_DYNAMIC(CDocument);
    public:
    	CDocument::CDocument() { 
    		//cout << "CDocument 被构建！ \n";
    	}
    
    	CDocument::~CDocument() { 
    		//cout << "CDocument 被销毁！ \n";
    	}
    };
    
    
    class CWnd : public CCmdTarget
    { 
    	DECLARE_DYNAMIC(CWnd);
    public:
    	CWnd::CWnd() { 
    		//cout << "CWnd 被构建！ \n";
    	}
    	CWnd::~CWnd() { 
    		//cout << "CWnd 被销毁！ \n";
    	}
    
    	//
    	virtual bool Create();
    	bool CreateEx();
    	virtual bool PreCreateWindow();
    };
    
    class CFrameWnd : public CWnd
    { 
    	DECLARE_DYNAMIC(CFrameWnd);
    public:
    	CFrameWnd::CFrameWnd() { 
    		//cout << "CFrameWnd 被构建！ \n";
    	}
    	CFrameWnd::~CFrameWnd() { 
    		//cout << "CFrameWnd 被销毁！ \n";
    	}
    
    	bool Create();
    	virtual bool PreCreateWindow();
    };
    
    class CView : public CWnd
    { 
    	DECLARE_DYNAMIC(CView);
    public:
    	CView::CView() { 
    		//cout << "CView 被构建！ \n";
    	}
    	CView::~CView() { 
    		//cout << "CView 被销毁！ \n";
    	}
    };
    
    // global function
    
    CWinApp* AfxGetApp();
    
    #endif // MFC_H

> MFC.cpp

#include "my.h" // it should be mfc.h, but for CMyWinApp definition, so...
    
    //全局变量
    extern CMyWinApp theApp;
    
    
    //全局函数
    CWinApp* AfxGetApp()
    { 
    	return theApp.m_pCurrentWinApp;
    }
    
    //类成员函数
    bool CWnd::Create() { 
    	cout << "CWnd::Create\n";
    	return true;
    }
    
    bool CWnd::CreateEx() { 		//扩展版创建窗口对象
    	cout << "CWnd::CreateEx\n";
    	PreCreateWindow();
    	return true;
    }
    
    bool CWnd::PreCreateWindow() { 		//创建窗口之前的预处理
    	cout << "CWnd::PreCreateWindow\n";
    	return true;
    }
    
    bool CFrameWnd::Create() { 		//扩展版创建窗口对象
    	cout << "CFrameWnd::Create\n";
    	CreateEx();
    	return true;
    }
    
    bool CFrameWnd::PreCreateWindow() { 		//创建窗口之前的预处理
    	cout << "CFrameWnd::PreCreateWindow\n";
    	return true;
    }
    
    //设置类别型录表中节点的内容
    static char szCObject[] = "CObject";	//类名
    struct CRuntimeClass CObject::classCObject = {  szCObject,sizeof(CObject),0xffff,NULL,NULL ,NULL };		//初始化节点
    static AFX_CLASSINIT _init_CObject(&CObject::classCObject);		//把类别节点加入到链表中，扩大类型表
    CRuntimeClass* CRuntimeClass::pFirstClass = NULL;		//类别表起点
    
    //链接所有的类别节点
    AFX_CLASSINIT::AFX_CLASSINIT(CRuntimeClass* pNewClass) { 
    	pNewClass->m_pNextClass = CRuntimeClass::pFirstClass;		//设置为其父类节点，由下至上进行查找
    	CRuntimeClass::pFirstClass = pNewClass;		//将起点改为添加之后的节点
    }
    
    CRuntimeClass* CObject::GetRuntimeClass() const { 
    	return &CObject::classCObject;
    }
    
    bool CObject::IsKindOf(const CRuntimeClass * pClass) const
    { 
    	CRuntimeClass* pClassThis = GetRuntimeClass();
    	while (pClassThis!=NULL)
    	{ 
    		if (pClassThis == pClass)
    			return true;
    		pClassThis = pClassThis->m_pBaseClass;		//向上（父类）寻找
    	}
    	return false;
    }
    
    //动态填充类别节点
    IMPLEMENT_DYNAMIC(CCmdTarget, CObject)
    IMPLEMENT_DYNAMIC(CWinThread,CCmdTarget)
    IMPLEMENT_DYNAMIC(CWinApp,CWinThread)
    IMPLEMENT_DYNAMIC(CWnd,CCmdTarget)
    IMPLEMENT_DYNAMIC(CFrameWnd,CWnd)
    IMPLEMENT_DYNAMIC(CDocument,CCmdTarget)
    IMPLEMENT_DYNAMIC(CView,CWnd)

> my.h

#pragma once
    
    #include"MFC.h"
    
    class CMyWinApp : public CWinApp
    { 
    public:
    	CMyWinApp::CMyWinApp() { 
    		//cout << "CMyWinApp 被构建！ \n";
    	}
    	CMyWinApp::~CMyWinApp() { 
    		//cout << "CMyWinApp 被销毁！ \n";
    	}
    
    	virtual bool InitInstance();
    };
    
    class CMyFrameWnd : public CFrameWnd
    { 
    	DECLARE_DYNAMIC(CMyFrameWnd)		//将类CMyFrameWnd也纳入类别型录表之中
    public:
    	CMyFrameWnd() { 
    		//cout << "CMyFrameWnd 被构建！ \n";
    		Create();
    	}
    	~CMyFrameWnd() { 
    		//cout << "CMyFrameWnd 被销毁！ \n";
    	}
    };
    
    class CMyDoc :public CDocument
    { 
    	DECLARE_DYNAMIC(CMyDoc)
    public:
    	CMyDoc::CMyDoc() { 
    
    	}
    
    	CMyDoc::~CMyDoc() { 
    
    	}
    };
    
    class CMyView :public CView
    { 
    	DECLARE_DYNAMIC(CMyView)
    public:
    	CMyView::CMyView() { 
    
    	}
    
    	CMyView::~CMyView() { 
    
    	}
    };

> my.cpp

#include "my.h"
    
    CMyWinApp theApp;		//其早于main函数就开始被创建
    
    bool CMyWinApp::InitInstance() { 
    	//cout << "CMyWinApp::InitInstance\n";
    	m_pMainWnd = new CMyFrameWnd;
    	return true;
    }
    
    //打印所有类别
    void PrintAllClasses() { 
    	CRuntimeClass* pClass;
    
    	for (pClass=CRuntimeClass::pFirstClass;pClass!=NULL;pClass=pClass->m_pNextClass)
    	{ 
    		cout << pClass->m_lpszClassName<<"\n";
    		cout << pClass->m_nObjectSize<<"\n";
    		cout << pClass->m_wSchema << "\n";
    	}
    }
    
    //扩展类别型录表
    IMPLEMENT_DYNAMIC(CMyFrameWnd,CFrameWnd)
    IMPLEMENT_DYNAMIC(CMyDoc,CDocument)
    IMPLEMENT_DYNAMIC(CMyView,CView)
    
    //------------------------------------------------------------------
    // main
    //------------------------------------------------------------------
    void main()
    { 
    	cout << "------------------------华丽的分割线----------------------\n";
    	CWinApp* pApp = AfxGetApp();
    
    	pApp->InitApplication();
    	pApp->InitInstance();
    	pApp->Run();
    
    	PrintAllClasses();
    	cout << "------------------------华丽的分割线----------------------\n";
    	CMyDoc* pMyDoc = new CMyDoc;
    	CMyView* pMyView = new CMyView;
    	CWnd* pMyWnd = pApp->m_pMainWnd;
    
    	cout << "pMyDoc->IsKindOf(RUNTIME_CLASS(CMyDoc)) " << pMyDoc->IsKindOf(RUNTIME_CLASS(CMyDoc)) << "\n";
    	cout << "pMyDoc->IsKindOf(RUNTIME_CLASS(CDocument)) " << pMyDoc->IsKindOf(RUNTIME_CLASS(CDocument)) << "\n";
    	cout << "pMyDoc->IsKindOf(RUNTIME_CLASS(CCmdTarget)) " << pMyDoc->IsKindOf(RUNTIME_CLASS(CCmdTarget)) << "\n";
    	cout << "pMyDoc->IsKindOf(RUNTIME_CLASS(CObject)) " << pMyDoc->IsKindOf(RUNTIME_CLASS(CObject)) << "\n";
    	cout << "pMyDoc->IsKindOf(RUNTIME_CLASS(CWinApp)) " << pMyDoc->IsKindOf(RUNTIME_CLASS(CWinApp)) << "\n";
    	cout << "pMyDoc->IsKindOf(RUNTIME_CLASS(CView)) " << pMyDoc->IsKindOf(RUNTIME_CLASS(CView)) << "\n";
    
    	cout << "pMyView->IsKindOf(RUNTIME_CLASS(CView)) " << pMyView->IsKindOf(RUNTIME_CLASS(CView)) << "\n";
    	cout << "pMyView->IsKindOf(RUNTIME_CLASS(CObject)) " << pMyView->IsKindOf(RUNTIME_CLASS(CObject)) << "\n";
    	cout << "pMyView->IsKindOf(RUNTIME_CLASS(CWnd)) " << pMyView->IsKindOf(RUNTIME_CLASS(CWnd)) << "\n";
    	cout << "pMyView->IsKindOf(RUNTIME_CLASS(CFrameWnd)) " << pMyView->IsKindOf(RUNTIME_CLASS(CFrameWnd)) << "\n";
    
    	cout << "pMyWnd->IsKindOf(RUNTIME_CLASS(CFrameWnd)) " << pMyWnd->IsKindOf(RUNTIME_CLASS(CFrameWnd)) << "\n";
    	cout << "pMyWnd->IsKindOf(RUNTIME_CLASS(CWnd)) " << pMyWnd->IsKindOf(RUNTIME_CLASS(CWnd)) << "\n";
    	cout << "pMyWnd->IsKindOf(RUNTIME_CLASS(CObject)) " << pMyWnd->IsKindOf(RUNTIME_CLASS(CObject)) << "\n";
    	cout << "pMyWnd->IsKindOf(RUNTIME_CLASS(CDocument)) " << pMyWnd->IsKindOf(RUNTIME_CLASS(CDocument)) << "\n";
    }
    //------------------------------------------------------------------

运行效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 1]

# 三、小结 #

现在看来，上述中的“DECLARE\_DYNAMIC与IMPLEMENT\_DYNAMIC”非常类似于Qt中的“QObject”，两者的作用均是用于赋予某个类一些能力，只不过“QObject”这个宏可能更强大一些。  
书中对这段代码的剖析也是非常精彩，记得在看这本书之前我从未想过链表可以这样构建，“宏”可以这样巧妙的在代码中使用，不过直至现在这本书中的内容我仍有许多不懂之处，所以仍需多总结多思考啊\*^\*。

> 参考资料：《深入浅出MFC》

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70]: /images/20221120/941524dac16f4d40bc243aec2bc50f99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 1]: /images/20221120/277330ee78f34bdf9881a728a47f1774.png