MFC六大关键技术

最新推荐文章于 2021-02-16 10:53:51 发布

土戈

最新推荐文章于 2021-02-16 10:53:51 发布

阅读量808

点赞数

分类专栏： MFC

原文链接：https://www.cnblogs.com/gaohongchen01/p/4090137.html

版权

MFC 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

MFC六大关键技术包括：

MFC Initialization —— MFC程序的初始化过程
RTTI（Runtime Type Information）—— 运行时类型识别
Dynamic Creation —— 动态创建
Persistence ——永久保存（串行化、序列化）
Message Mapping —— 消息映射
Message Routing —— 消息传递

MFC程序的初始化过程

首先，我们用VS2010建立一个Win32应用程序，在项目的配置属性中链接MFC库，并输入以下代码：

#include <afxwin.h>
class MyApp : public CWinApp
{
public:
    BOOL InitInstance() //②程序入点
    {
        CFrameWnd *Frame=new CFrameWnd();//构造框架
        m_pMainWnd=Frame; //将m_pMainWnd 设定为Frame;
        Frame->Create(NULL,_T("最简单的窗口"));//建立框架
        Frame->ShowWindow(SW_SHOW); //显示框架
        return true; //返回
    }
};
MyApp theApp; //①建立应用程序。

运行结果：

然后再更换为以下代码：

#include <afxwin.h>
class MyApp : public CWinApp
{
public:
    BOOL InitInstance() //②程序入点
    {
        AfxMessageBox(_T("程序依然可以运行！"));
        return true; //返回
    }
};
MyApp theApp; //①建立应用程序。
程序运行结果为：

　　我们知道，C++控制台程序的入口点函数为main()函数，而Windows应用程序的入口点函数为WinMain()。然而，上述程序并没有main()或WinMain()函数，也能运行。实际上，在main()或WinMain()函数执行之前，全局对象会先运行。在上述程序中我们定义了全局对象theApp，程序会首先执行theApp。只要我们构造了CWinApp 对象，就可以执行WinMain()函数。

　　整个过程大体为：theApp对象初始化-->调用类名构造函数-->调用AfxWinMain函数-->调用CWinApp类的成员函数完成各种初始化（包括InitApplication 、InitInstance 、Run(包含消息循环)）-->Winmain函数执行。

　　在MFC中，InitApplication()和InitInstance()为CWinApp的两个虚函数，前者负责”每个程序只做一次“的操作，后者负责”每个例程都得做一次“的操作。在Windows应用程序中，如果我们想改变窗口的属性，只需改写初始化函数InitInstance()即可。

运行时类型识别　　

指在只有一个指向基类的指针或引用时，确定所指对象的准确类型。其常被说成是C++的四大扩展之一（其他三个为异常、模板和名字空间）。

使用RTTI的两种方法：

　　1、typeid()

　　第一种就像sizeof()，它看上像一个函数，但实际上它是由编译器实现的。typeid()带有一个参数，它可以是一个对象引用或指针，返回全局typeinfo类的常量对象的一个引用。可以用运算符“= =”和“!=”来互相比较这些对象，也可以用name()来获得类型的名称。如果想知道一个指针所指对象的精确类型，我们必须逆向引用这个指针。比如：

#include <typeinfo>
#include <iostream>
#include <cmath>
using namespace std;
class Shape
{
public :
    int area(float r)
    {
        float s=3.14*pow(r,2);
        return s;
    }
};
int main()
{  
    Shape* shape=new Shape;
    cout<< typeid(*shape).name()<<endl;
    system("pause");
}

　　为了保持一致性，typeid()也可以用于内部类型，所以下面的表达式结果为true:

typeid(36) == typeid(int)
typeid(0) == typeid(int)

int i;
typeid(i) == typeid(int)
typeid(&i) ==typeid(int*)

　　可以用typeid 检查基本类型和非多态类型：

//可以用typeid 检查基本类型和非多态类型： 
#include <typeinfo>
#include <iostream>
using namespace std;
typedef  unsigned int UINT ;
int main()
{  
    cout<< typeid(UINT).name()<<endl;
    cout<< typeid(string).name()<<endl;
    system("pause");
}

　　用typeid分析指针与引用的区别：

#include <typeinfo>
#include <iostream>
using namespace std;
class B
{   
public:  
    virtual double fun() 
    { 
        return 0.1; 
    }   
};
class D :public B   
{
};
int main()
{   
    B *p = new D;    
    B &r = *p;    //无名对象照样有别名
    cout<<(typeid(p)==typeid(B*)); //仅指向子类中父类部分
    cout<<(typeid(p)!=typeid(D*));  //而非指向整个子类对象
    cout<<(typeid(r)==typeid(D));   //引用的类型却是子类的
    cout<<(typeid(*p)==typeid(D)); //间址访问的是子类对象
    cout<<(typeid(*p)!=typeid(B));  //而非父类
    cout<<(typeid(&r)==typeid(B*)); //引用的地址是父类的
    cout<<(typeid(&r)!=typeid(D*));  //而非子类的
    system("pause");
    return 0;
}

　　2、dynamic_cast <type-id> (expression)

　　该运算符把expression转换成type-id类型的对象。Type-id 必须是类的指针、类的引用或者void*，不可是对象；如果 type-id 是类指针类型，那么expression也必须是一个指针，如果 type-id 是一个引用，那么 expression 也必须是一个引用。

　　dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

#include <typeinfo>
#include <iostream>
using namespace std;
class Shape
{
public:
    virtual void Draw()
    {
    }
};
class Circle:public Shape
{
public:
    virtual void Draw()
    {
    }
};
int main()
{  
    Shape* sp=new Circle;
    Circle* cp=dynamic_cast<Circle*>(sp);
    if(cp)  
        cout<<"cast successful"<<endl;;
    system("pause");
}

如何使用RTTI：

先激活RTTI；
对象所属类型必须是多态类族；
若使用dynamic_cast<>转换一个引用，则要使用异常处理机制，因为它可能抛出 std::bad_cast异常；当使用dynamic_cast<>运算符转换一个指针时，定要检查结果是否为NULL
若使用typeid (*p)来检索对象的类型信息，又恰碰 p == NULL时，将抛出std::bad_typeid异常；

动态创建

　　MFC中很多地方都使用了动态创建技术，动态创建就是在程序运行时创建指定类的对象。例如MFC的单文档程序中，文档模板类的对象就动态创建了框架窗口对象、文档对象和视图对象。动态创建技术对于希望了解MFC底层运行机制的朋友来说，非常有必要弄清楚。

　　要做到把自己的类交给MFC，MFC用同一方法把不同的类一一准确创建，我们就要用到链表，记录各类的关键信息，在动态创建的时候找出这些信息。

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;
};

简单地说m_pfnCreateObject保存了一个函数的地址，将会创建一个对象，m_pfnCreateObject指向不同的函数，我们就会创建不同类型的对象。CreateObject()即为m_pfnCreateObject指向的函数。这样，我们用函数指针m_pfnCreateObject，就随时可new新对象了。

　　在设计CRuntimeClass类时，只有类名（和基类名）的不同，这正是我们想要的，因为动态创建也象RTTI那样用到两个宏，只要传入类名和基类作宏参数，就可以满足条件。类声明中使用DECLARE_DYNCREATE（CLASSNMAE）宏和在类的实现文件中使用IMPLEMENT_DYNCREATE（CLASSNAME，BASECLASS）宏来为我们加入链表。

　　m_pBaseClass指针只会沿着基类上去，会漏掉其它分支。在动态创建时，必需检查整个链表，看有多少个要动态创建的对象，即是说要从表头（pFirstClass）开始一直遍历到表尾（m_pNextClass=NULL），不能漏掉一个CRuntimeClass对象。所以每当有一个新的链表元素要加入链表时，就要使新的链表元素成为表头，且m_pNextClass指向原来链表的表头，即像下面那样（当然，这些不需要我们操心，是RTTI宏帮助我们完成的）：

pNewClass->m_pNextClass=CRuntimeClass::pFirstClass;//新元素的m_pNextClass指针指向想加入的链表的表头。   
CRuntimeClass::pFirstClass=pNewClass;//链表的头指针指向刚插入的新元素。

有了上面的链表，我们就可以分析动态创建了。

动态创建的步骤：

有了一个包含类名，函数指针，动态创建函数的链表，我们就可以知道应该按什么步骤去动态创建了：

获得一要动态创建的类的类名（假设为A）
将A跟链表里面每个元素的m_lpszClassName指向的类名作比较
若找到跟A相同的类名就返回A所属的CRuntimeClass元素的指针
判断m_pfnCreateObject是否有指向创建函数，有则创建对象，并返回该对象

代码演示如下（以下两个函数都是CRuntimeClass类函数）：

复制代码

///以下为根据类名从表头向表尾查找所属的CRuntimeClass对象   
  
CRuntimeClass* PASCAL CRuntimeClass::Load()   
{   
char szClassXXX[64];   
CRuntimeClass* pClass;   
cin>>szClassXXX;      //假定这是我们希望动态创建的类名   
for(pClass=pFirstClass;pClass!=NULL;pClass=pClass->m_pNextClass)   
{   
     if(strcmp(szClassXXX,pClass->m_lpszClassName)==0)   
     return pClass;   
}   
     return NULL;   
}   
  
///根据CRuntimeClass创建对象///   
CObject* CRuntimeClass::CreateObject()   
{   
     if(m_pfnCreateObject==NULL) return NULL;   
     CObject *pObject;   
     pObject=(* m_pfnCreateObject)();              //函数指针调用   
     return pObject;                                      
}

复制代码

有了上面两个函数，我们在程序执行的时候调用，就可以动态创建对象了。

简单实现动态创建：

我们还可以更简单地实现动态创建，大家注意到，就是在我们的程序类里面有一个RUNTIME_CLASS(class_name)宏，作用就是得到类的RunTime信息，即返回class_name所属CRuntimeClass的对象。这个宏在MFC里定义为：

RUNTIME_CLASS(class_name)  ((CRuntimeClass*)(&class_name::class##class_name))

在我们的应用程序类(CMyWinApp)的InitInstance()函数下面的CSingleDocTemplate函数中，有：

RUNTIME_CLASS(CMyDoc),
RUNTIME_CLASS(CMainFrame),       // main SDI frame window
RUNTIME_CLASS(CMyView)

构造文档模板的时候就用这个宏得到文档、框架和视的RunTime信息。有了RunTime信息，我们只要一条语句就可以动态创建了，如：

classMyView->CreateObject();      //对象直接调用用CRuntimeClass本身的CreateObject()

总结：

最后再总结和明确下动态创建的具体步骤：

定义一个不带参数的构造函数（默认构造函数）；因为我们是用CreateObject()动态创建，它只有一条语句就是return new XXX，不带任何参数。所以我们要有一个无参构造函数。
类说明中使用DECLARE_DYNCREATE（CLASSNMAE）宏；和在类的实现文件中使用IMPLEMENT_DYNCREATE（CLASSNAME，BASECLASS）宏；这个宏完成构造CRuntimeClass对象，并加入到链表中。
使用时先通过宏RUNTIME_CLASS得到类的RunTime信息，然后使用CRuntimeClass的成员函数CreateObject创建一个该类的实例。
CObject* pObject = pRuntimeClass->CreateObject();//完成动态创建。

文档永久保存（串行化、序列化）

　　我们可以利用CArchive类将对象数据保存到永久设备上，这样，即使应用程序关闭，我们也可以将从磁盘文件中读取对象数据，然后在内存中重新构建相应的对象，这种让对象数据持久性的过程，即MFC的连续存储机制称之为序列化（Serialize）。

　　MFC文档的序列化过程包括：创建空文档、打开文档、保存文档和关闭文档四个操作。

　　从单文档的序列化过程可以看出：打开和保存文档时，系统都会调用Serialize函数。事实上，MFC AppWizard在创建文档应用程序框架时已在文档类中重载了Serialize函数，通过在该函数中添加代码可达到实现数据序列化的目的。

消息映射、消息传递

土戈

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
MFC六大关键技术

MFC六大关键技术包括：MFC Initialization —— MFC程序的初始化过程 RTTI（Runtime Type Information）—— 运行时类型识别 Dynamic Creation —— 动态创建 Persistence ——永久保存（串行化、序列化） Message Mapping —— 消息映射 Message Routing —— 消息传递MFC程序的初始化过程首先，我们用VS2010建立一个Win32应用程序，在项目的配置属性中链接MFC库，并输入以下代
复制链接

扫一扫