吕鑫MFC学习系列四

最新推荐文章于 2023-06-06 22:59:40 发布

langb2014

最新推荐文章于 2023-06-06 22:59:40 发布

阅读量2.4k

点赞数

本文链接：https://blog.csdn.net/langb2014/article/details/50642560

版权

第一个是Win32工程转换而成MFC工程：

建一个win32项目，window应用程序，然后删除了所有函数，只留下主函数，编写过程中转MFC，所以右击项目，选择静态库MFC，然后在stdafx.h中用afxwin.h代替window.h。基本环境设置完了，下面是结果显示：

代码实现：

//MFC架构组成
//1、CWinApp的派生类
//2、必须在全局区定义一个派生类的对象
//3、在CWinApp的派生类内必须要有InitInstance虚函数的重写函数
//今后在MFC软件工程就以App类中的InitInstance函数作为主函数
//另外，链接MFC的平台使用Static Library（一般要使用这个便于拷贝给用户，封装了很多动态库）或Shared Dll都可以。
//
//
//

class CMyApp:public CWinApp
{
	virtual BOOL InitInstance()
	{
		AfxMessageBox("由Win32工程装换而成MFC软件工程");
		return TRUE;
	}
};
CMyApp theAPP;

看一下Win32消息管理机制：

首先建一个win32程序，然后添加资源文件，后缀为.rc

然后第一步在主函数中添加DialogBox(hInstance,(LPCTSTR)IDD_MAINDLG,NULL,theProc);

第二步就是实现theProc函数响应，这段函数响应通过MSDN查询到DialogBox中的最后一个参数，点击到里面的例子，将代码复制到main函数上面。

第三步就是添加各种命令操作依次添加，这里每一步添加我就不详细按先后顺序说明了，可以看吕鑫老师的教程，我直接把代码贴在下面：

// Test32.cpp : 定义应用程序的入口点。

#include "stdafx.h"
#include "Test32.h"
#include "resource.h"
#include <stdio.h>

BOOL CALLBACK theProc(
	HWND hwndDlg,
	UINT uMsg,
	WPARAM wParam,
	LPARAM lParam
	)
{
	switch (uMsg)
	{
	case WM_INITDIALOG:
		//	当对话框还没有显示出来，准备工作
		MoveWindow(hwndDlg, 400, 200, 500, 350, FALSE);
		SetWindowText(hwndDlg, L"测试窗口标题");
		return TRUE;
	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDOK:
		case IDCANCEL:
			EndDialog(hwndDlg, LOWORD(wParam));
			return TRUE;
		}
		break;
	case WM_LBUTTONDOWN:
		{
		int x = LOWORD(lParam);
		int y = HIWORD(lParam);
		TCHAR s[200];
		_stprintf(s, L"x=%d,y=%d", x, y);
		MessageBox(hwndDlg, s, L"提示", 0);
		}
		return TRUE;
	case WM_MOUSEMOVE:
		{
		 int x = LOWORD(lParam);
		 int y = HIWORD(lParam);
		 TCHAR s[200];	
		 _stprintf(s, L"x=%d,y=%d", x, y);
		 SetWindowText(hwndDlg, s);
		}
		return TRUE;
	case WM_PAINT://绘图消息
		OutputDebugStringW(L"绘图消息来临\n");//窗口刷新消息
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(hwndDlg, &ps);
		Ellipse(hdc,0,0,300,200);
		EndPaint(hwndDlg, &ps);
		return TRUE;
	}
	return FALSE;//false表示系统默认处理，true的话则连基本窗口都无法显示
}

int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPTSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
	int	nRet=DialogBox(hInstance,(LPCTSTR)IDD_MAINDLG,NULL,theProc);
	return 0;
}

最后贴一下结果图：

（基本功能就是跟踪坐标并显示坐标和弹出坐标提示窗口）

直接在VS2013下面新建MFC项目具体过程（vs比较方便，当然vc++6.0也一样）：

打开类资源视图能看到App类和Dlg类，然后是App类来调用Dlg类，Dlg类添加各种按钮及相应的函数，添加消息映射可以参考here。

MFCApp调用Dlg的部分就是在InitInstance()函数这儿：

BOOL CMFCApp::InitInstance()
{
	CWinApp::InitInstance();
	CShellManager *pShellManager = new CShellManager;
	CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
	SetRegistryKey(_T("应用程序向导生成的本地应用程序"));

	CMFCDlg dlg;
	m_pMainWnd = &dlg;
	INT_PTR nResponse = dlg.DoModal();
       ......

CDialog::DoModal()的返回值为IDOK，IDCANCEL。表明操作者在对话框上选择“确认”或是“取消”。在调试的时候可以跟踪到CMFCDlg类里面的初始化函数这里，

BOOL CMFCDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();
	SetWindowText(L"InitDialog");
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	//SetIcon(m_hIcon, FALSE);		// 设置小图标

	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

具体里面每个函数的内容怎么实现的就不详细说明了，有什么错误，请留言。

MFCDlg.cpp代码如下：

// MFCDlg.cpp : 实现文件
//

#include "stdafx.h"
#include "MFC.h"
#include "MFCDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif
CMFCDlg::CMFCDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CMFCDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDI_ICON1);
}

void CMFCDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CMFCDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONDOWN()
END_MESSAGE_MAP()
BOOL CMFCDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();
	SetWindowText(L"InitDialog");
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	//SetIcon(m_hIcon, FALSE);		// 设置小图标

	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CMFCDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // 用于绘制的设备上下文

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// 使图标在工作区矩形中居中
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// 绘制图标
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CMFCDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}
void CMFCDlg::OnMouseMove(UINT nFlags, CPoint point)
{
	CString str;
	str.Format(L"x=%d,y=%d", point.x, point.y);
	if (MK_CONTROL &nFlags)
		str += "按下Ctrl";
	if (MK_SHIFT &nFlags)
		str += "按下Shift";
	if (MK_LBUTTON &nFlags)
		str += "按下左键";
	if (MK_RBUTTON &nFlags)
		str += "按下右键";
	SetWindowText(str);
	CDialogEx::OnMouseMove(nFlags, point);
}
void CMFCDlg::OnLButtonDown(UINT nFlags, CPoint point)
{
	CString str;
	str.Format(L"x=%d,y=%d",point.x, point.y);
	if (MK_CONTROL &nFlags)
		str += "按下Ctrl";
	if (MK_SHIFT &nFlags)
		str += "按下Shift";
	//AfxMessageBox(str);
	CDialogEx::OnLButtonDown(nFlags, point);
}

中途有图标添加问题的同学，可以查看我的下面几篇日志。

运行结果图：

========================================================================================================

这一节的知识点科普：MFC六大关键技术

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()函数。

　　例如，我们再建立一个Win32控制台程序，代码如下：

 
 
  
  #include<iostream>
 
 

 
 
  
  using
  
   
  
  namespace
  
   std;
 
 


 
 
class test

 
 
  
  public
  
  :
 
 {
    test()

 
 
  
          cout
  
  <<
  
  "
  
  请改变你对main()函数的看法！
  
  "
  
  <<
  
  endl;
 
     {

 
 
    }

 
 
  
  test test1;
 
 };


 
 
int main()

 
 
  
      system(
  
  "
  
  pause
  
  "
  
  );
 
 {

 
 
    return 0;

 
 
  
  }

运行结果：

程序首先执行了全局对象test1的构造函数。

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

运行时类型识别

　　这方面请阅读我的另一篇博客：RTTI（运行时类型识别）：http://www.cnblogs.com/gaohongchen01/p/4085908.html

动态创建

　　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函数，通过在该函数中添加代码可达到实现数据序列化的目的。

消息映射、消息传递

langb2014

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
吕鑫MFC学习系列四

========================================================================================================这一节的知识点科普：MFC六大关键技术MFC六大关键技术包括：MFC Initialization —— MFC程序的初始化过程RTTI（Runtime Typ
复制链接

扫一扫