MFC原理第三讲.RTTI运行时类型识别

一丶什么是RTTI

　　　　RTTI. 运行时的时候类型的识别. 运行时类型信息程序.能够使用基类(父类)指针或者引用来检查这些指针或者引用所指的对象. 实际派生的类型

　　简单来说就是使用父类指针检查这个对象是属于哪个类.

1.本篇博客需要弄清的问题

　　1.1 MFC为什么要构建RTTI

　　1.2 DECLARE_DYNAMIC 宏

　　1.3 IMPLEMENT_DYNAMIC 宏

　　1.4 RUNTIME_CLASS 宏

　　1.5 CRuntime Class 结构体

2.简单了解关键字的使用

　　1.类中定义的static的变量的作用以及怎么初始化.

　　2.类中定义的const的变量的作用以及怎么初始化

　　3.类中的 static + const定义的变量的作用以及怎么初始化.

二丶C++简单的RTTI运行类型识别

　　在讲解我们要搞清楚的问题的时候.写一个简单的小例子. 使用C++自带的编译时的RTTI程序. 注意是编译时.

具体做法:

　　1. 要使用typeid 关键字 typeid(对象) typeid (类名)

　　2.首先要包含头文件 <typeinfo.h>

　　3.启动C++自己的类型. 属性 -> 配置属性 -> C/C++ -> 语言 -> 启用运行时类型信息命令行加的是 /GR 我们也可以直接加/GR

例如下图:

1. 首先我们创建两个类. 一个是 CDog 一个是CCat.

2.然后我们的Main函数定义 CDog 对象以及CCat对象. 并且判断 CDog对象是否属于CDog这个类.

3.如果属于我们则进行打印.否则相反.

具体代码:

#include <stdio.h>
#include <typeinfo.h>
#include "Dog.h"
#include "Cat.h"
int main(int argc, char *argv[])
{
    CDog dog;
    CCat cat;
    if (typeid(dog) == typeid(CDog)) 判断dog对象是否属于 CDog类   主要就是这行代码
    {
        printf("是属于这个对象\r\n");
    }
    else
    {
        printf("不是属于这个对象\r\n");
    }

    system("pause");
}

实现应用截图:

这个就是简单的RTTI运行时类型识别了.

三丶类中的 static关键字.const关键字 static + const 关键字的作用以及初始化

　　1.static关键字修饰的变量.外部进行初始化.并且不依赖与对象.也就是说直接类名::变量则可以调用类型类名::成员变量 = 值;

　　2.const关键字修饰的变量只能读不能改. 初始化的时候必须在类的构造的初始化列表进行初始化.

　　3.static + const修饰的变量. 只能读不能改. 类名直接调用. 初始化的时候在外部进行初始化 const 类型类名::成员变量 = 值;

四丶MFC为什么自己构建RTTI

　　MFC因为出现的年代比较早.所以自己实现了RTTI. 而且依靠的就是两个宏

　　1.2 的 DECLARE_DYNAMIC 宏

　　1.3 的 IMPLEMENT_DYNAMIC 宏

其中1.3里面的宏也包含了一个关键的宏 RUNTIME_CLASS 以及关键结构体 CRuntime Class

一丶使用1.2 宏 1.3宏.

　　现在我们要让我们自己的类拥有RTTI运行时类型识别.

　　步骤:

　　　　1.我们的自己的WinApp 类里面定义 DECLARE_DYNAMIC宏

　　　　2.main函数之前使用 IMPLEMENT_DYNAMIC 宏

　　　　3.使用 IsKindOf(CRuntime Class *) 来判断是否是继承父类. 因为是 CRuntime Class * 所以我们要使用宏包含我们的父类 RUNTIME_CLASS(父类)

　　　　4.如果是继承父类则返回1. 否则返回0

知道步骤了.那么打开第一篇博客的代码. 自己实现的窗口程序.去编写.

　　1.自己类里面定义DECLARE_DYNAMIC宏截图:

　　　2.自己类的实现文件中定义IMPLEMENT_DYNAMIC(自己的类名,父类类名)

　　3.自己的类已经拥有了Rtti 类型识别.使用Rtii 运行识别.

二丶 RUNTIME_CLASS 宏解析

　　上面我们使用 RUNTIME_CLASS 宏来做使用那么我们看一下MFC怎么定义的.

#define _RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name))

其实也是一个宏.不过我们可以拆解一下.

#define _RUNTIME_CLASS(CWinApp) ((CRuntimeClass*)(&CWinApp::classCWinApp))

　其中 ##代表了链接的意思也就是 Class##ClassName 可以变成 ClassWinApp

　　所以上面我们用宏写的代码下方可以替换成我们解析出来的宏.

返回了一个 CRuntime Class * . 返回的是CWinAPP里面的一个成员的地址.因为前边有一个取地址符号..

首先看一下CRuntimeClass结构体吧

三丶CRuntimeClass结构体

struct CRuntimeClass
{
// Attributes
    LPCSTR m_lpszClassName;           类名
    int m_nObjectSize;                      类的大小
    UINT m_wSchema;                      加载类的编号
    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;       // 执向下一个CRunTimeClass
    const AFX_CLASSINIT* m_pClassInit;
};

因为上面成员较多.下方简化一下.

struct CRuntimeClass
{
// Attributes
    LPCSTR m_lpszClassName;           类名
    int m_nObjectSize;                      类的大小
    UINT m_wSchema;                      加载类的编号
    ...
    BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;  判断函数是否是父类
    ...
    CRuntimeClass* m_pNextClass;       // 执向下一个CRunTimeClass
    
};

这个是一个链表. 是记录类型的一个结构. 因为是链表.所以可以进行检查.

四丶DECLARE_DYNAMIC 宏解析

　　其实 DECLARE_DYNAMIC 宏也是一个文字替换的东西.我们可以看下代码.

#define DECLARE_DYNAMIC(class_name) \
public: \
    static const CRuntimeClass class##class_name; \
    virtual CRuntimeClass* GetRuntimeClass() const; \


替换后是下边的代码.


public: 
    static const CRuntimeClass classCMyApp; 
    virtual CRuntimeClass* GetRuntimeClass() const;

在我们的CMyAPP 里面的宏则可以直接去掉了.

做的事情;

　　1.申明了 static const 全局可读的变量. 也就是一个类型记录信息结构体 CRuntimeClass 结构

　　　　问题: 既然是static const定义的.那么肯定是在外面进行初始化的.也就是我们的

IMPLEMENT_DYNAMIC 宏.而这个宏内部还包含了宏.并且对我们添加了默认参数.

#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew, class_init) \
    AFX_COMDAT const CRuntimeClass class_name::class##class_name = { \
        #class_name, sizeof(class class_name), wSchema, pfnNew, \
            RUNTIME_CLASS(base_class_name), NULL, class_init }; \
    CRuntimeClass* class_name::GetRuntimeClass() const \
        { return RUNTIME_CLASS(class_name); }

我们简化一下. 其实也是一个文字替换游戏.

const CRuntimeClass CMyApp::classCMyApp = 
{
        "CMyApp", sizeof(class CMyApp), NULL, NULL, 
        RUNTIME_CLASS(CWinApp), NULL, NULL
}; 
CRuntimeClass* CMyApp::GetRuntimeClass() const 
{ 
    return RUNTIME_CLASS(CMyApp);
}

其实就是对我们的static + const 变量进行初始化.

上图内部还有一个RUNTIME_CLASS 我们因为上面解析过了RUNTIME_CLASS 知道了.其实是获取 CWinAPP::classCWinapp 成员.

所以可以继续进行替换.

替换完如下.

const CRuntimeClass CMyApp::classCMyApp = 
{
        "CMyApp", sizeof(class CMyApp), NULL, NULL, 
        (CRuntimeClass*)(&CWinApp::classCWinApp), NULL, NULL
}; 
CRuntimeClass* CMyApp::GetRuntimeClass() const 
{ 
    return(CRuntimeClass*)(&CMyApp::classCWinApp);
}

代码截图:

我们的IMPLEMENT_DYNAMIC宏就等价于下面的代码了.

　　1. 初始化类内部的 CRuntimeClass 结构的成员.

　　2.添加了一个获取父类的ClassCWinAPP的成员了.

五丶RTTI总结

　　根据第四小节.我们已经把所有宏的本身模样还原出来了.看的杂乱无章.但是总结一下很简单.

　　1. 首先有一个结构叫做CRuntimeClass. 里面存储了类型说明. 比如类名称.大小. 以及判断是否是父类....

　　2. 有一个宏叫做 DECLARE_DYNAMIC宏. 这个宏就是定义了一个自己的一个CRuntimeClass 结构的成员.并且添加了一个获取自己这个成员的一个虚函数.

　　3. 实现宏IMPLEMENT_DYNAMIC 其实就是对DECLARE_DYNAMIC 中定义的CRuntimeClass成员进行初始化. 并且实现了获取自己这个成员的虚函数.

六丶RTTI中运行时类型识别的方法解析

　　上方我们讲了RTTI 以及CRuntimeClass 以及两个宏的总结. 那么我们要使用就是使用 isKindOf来使用. 那么解析下这个函数怎么使用了.

　　　　1.取出我们自己当前对象的 ClassCMyWinApp 指针.

　　　　2.循环遍历是否等于父类

　　　　3.不等于父类则进行遍历. 因为CRuntimeClass是一个链表结构. 一直进行遍历.地址比较.如果是则返回True

因为代码截图比教麻烦.所以直接贴里面的核定代码了.

BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const
{
    ....
    CRuntimeClass* pClassThis = GetRuntimeClass();  获取自己的CRuntimeClass 成员

    ...
    return pClassThis->IsDerivedFrom(pClass); 进行判断.
}


BOOL CRuntimeClass::IsDerivedFrom(const CRuntimeClass* pBaseClass) const
{
      其余代码省略
    const CRuntimeClass* pClassThis = this;  得到字节的CRuntimeClass成员

    while (pClassThis != NULL)                       循环遍历不是NULL
    {
        if (pClassThis == pBaseClass)           如果是父类则返回TRUE
            return TRUE;
        pClassThis = pClassThis->m_pBaseClass;  否则等于父类指针.继续遍历判断
    }
    return FALSE;       //  没有返回FALSE
}

七丶编写代码打印输出父类信息.以及继承关系

　　　　既然我们自己类的内部存储着CRuntimeClass *的指针. 而且是一个链表. 它父类也有自己的. 那么完全可以进行遍历.打印出父类的信息.

实现思路:

　　　　1.获取自己的CRuntimeClass *指针

　　　　2.遍历CRuntimeClass 成员是否为NULL

　　　　3.不为NULL 依次打印出结构体的内容

　　　　4. 当前的CRunTimeClass 指针修改为父类的CRuntimeClass * 指针

具体代码实现:

void CMyApp::PrintParentRuntimeInfo()
{
    //1.获取自己当前的CRuntimeClass信息. 进行遍历.
    CRuntimeClass *pCurClass = GetRuntimeClass();
    //进行循环
    CString str;
    while (NULL != pCurClass)
    {
        str = "";
        str.Format(TEXT("类的名称 = %s \r\n"),pCurClass->m_lpszClassName);  //类的名称
        OutputDebugString(str);
        str = "";
        str.Format(TEXT("类的大小 = %d \r\n"),pCurClass->m_nObjectSize);
        OutputDebugString(str);
        str = "";
        str.Format(TEXT("类的编号%d \r\n"), pCurClass->m_wSchema);
        OutputDebugString(str);

        str = "";
        str.Format(TEXT("类的父类指针 %p \r\n"), pCurClass->m_pBaseClass);
        OutputDebugString(str);

        if (pCurClass->m_pBaseClass != nullptr)
        {
            
            str = "";
            str.Format(TEXT("类的父类名称 %s \r\n"), pCurClass->m_pBaseClass->m_lpszClassName);
            OutputDebugString(str);
        }
        
        
        str = TEXT("--------------------------------\r\n");
        OutputDebugString(str);
        pCurClass = pCurClass->m_pBaseClass; //一直遍历到顶层位置
    }
}