MFC内部运行来龙去脉追踪

最新推荐文章于 2024-05-26 23:00:41 发布
最新推荐文章于 2024-05-26 23:00:41 发布
阅读量821 收藏
点赞数
分类专栏： MFC 文章标签： mfc null initialization thread listview windows

 

摘自：http://www.cnblogs.com/witxjp/archive/2010/04/21/1717564.html

1.全局对象theApp先于WinMain函数构造，而theApp是一个派生类的对象，故先调用基类CWinApp的构造函数，再调用派生类对象的构造函数。

　　CWinApp的构造函数定义于APPCORE.CPP文件中

  

CWinApp构造函数主要完成this指针的赋值，将全局对象theApp的this指针赋值给全局唯一实例。该构造函数有一参数，我们在默认调用的时候却没有指定参数，其实这是因为有默认值，

追踪AFXWIN.h头文件查看CWinApp类的定义可知。

class CWinApp : public CWinThread
{
 DECLARE_DYNAMIC(CWinApp)
public:

// Constructor
 CWinApp(LPCTSTR lpszAppName = NULL);     // app name defaults to EXE name

　　　......

接着调用我们自己派生类的构造函数，我们可以做一些数据成员的初始化操作。

 

 

2.全局对象之后即是WinMain函数的调用，在MFC中对WinMain进行了封装。所以在文件中查找WinMain是找不到的。可以在源文件的class CAboutDlg : public CDialog这一行加上断点，

F5运行，程序停在了

 

代码处，而同时可以看到该代码位于APPMODUL.cpp中。说明程序运行时加载了该函数，有点像我们的WinMain函数。go to definition可以看到#define _tWinMain   WinMain，_tWinMain正是我们的WinMain。

而为什么是_tWinMain而不是WinMain执行，这主要是MFC做了手脚，在MFC开始运行时就运行_tWinMain函数。其中又调用了AfxWinMain函数。在MFC源代码中查找一下AfxWinMain，在WINMAIN.cpp中可以找到AfxWinMain的实现：

 

稍加整理，可看到AfxWinMain主要做些什么事：

 

在APPINIT.cpp中查看AfxWinInit的实现如下:

 

AfxInitThread函数利用钩子函数将消息映射机制引入MFC的Message Map中，然后再回到默认的DefWindowProc。而AfxWinInit也主要做些初始化工作，完成一些初始细节配置。

之后是pApp->Application()调用了，由于派生类没有改写，故调用基类CWinApp::Application(),回到APPCORE.CPP文件：

 

可以看到主要做些内部管理。

然后是pApp->InitInstance()调用，派生类进行了改写，所以调用的是派生类的InitInstance()，如下：

 

在派生类的InitInstance函数中产生了一个CMainFrame窗口对象，故先调用基类CMDIFrameWnd的构造函数，CMDIFrameWnd的基类是CFrameWnd，故调用CFrameWnd的构造函数，在WinFrm.cpp文件中

CFrameWnd::CFrameWnd()
{
 ASSERT(m_hWnd == NULL);

 m_nWindow = -1;                 // unknown window ID
 m_bAutoMenuEnable = TRUE;       // auto enable on by default
 m_lpfnCloseProc = NULL;
 m_hMenuDefault = NULL;
 m_hAccelTable = NULL;
 m_nIDHelp = 0;
 m_nIDTracking = 0;
 m_nIDLastMessage = 0;
 m_pViewActive = NULL;

 m_cModalStack = 0;              // initialize modality support
 m_phWndDisable = NULL;
 m_pNotifyHook = NULL;
 m_hMenuAlt = NULL;
 m_nIdleFlags = 0;               // no idle work at start
 m_rectBorder.SetRectEmpty();

 m_bHelpMode = HELP_INACTIVE;    // not in Shift+F1 help mode
 m_dwPromptContext = 0;

 m_pNextFrameWnd = NULL;         // not in list yet

 m_bInRecalcLayout = FALSE;
 m_pFloatingFrameClass = NULL;
 m_nShowDelay = -1;              // no delay pending

 AddFrameWnd();
}

一直追踪到基类CWnd，CCmdTarget，CObject都没有发现产生窗口（Create）的操作，当然在产生窗口之前首先要注册窗口。其实Create的调用是在pMainFrame->LoadFrame(IDR_MAINFRAME）

中完成的。即CFrameWnd::LoadFrame()

BOOL CFrameWnd::LoadFrame(UINT nIDResource, DWORD dwDefaultStyle,
 CWnd* pParentWnd, CCreateContext* pContext)
{
 // only do this once
 ASSERT_VALID_IDR(nIDResource);
 ASSERT(m_nIDHelp == 0 || m_nIDHelp == nIDResource);

 m_nIDHelp = nIDResource;    // ID for help context (+HID_BASE_RESOURCE)

 CString strFullString;
 if (strFullString.LoadString(nIDResource))
  AfxExtractSubString(m_strTitle, strFullString, 0);    // first sub-string

 VERIFY(AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG));

 // attempt to create the window
 LPCTSTR lpszClass = GetIconWndClass(dwDefaultStyle, nIDResource);
 LPCTSTR lpszTitle = m_strTitle;
 if (!Create(lpszClass, lpszTitle, dwDefaultStyle, rectDefault,
   pParentWnd, MAKEINTRESOURCE(nIDResource), 0L, pContext))
 {
  return FALSE;   // will self destruct on failure normally
 }

 // save the default menu handle
 ASSERT(m_hWnd != NULL);
 m_hMenuDefault = ::GetMenu(m_hWnd);

 // load accelerator resource
 LoadAccelTable(MAKEINTRESOURCE(nIDResource));

 if (pContext == NULL)   // send initial update
  SendMessageToDescendants(WM_INITIALUPDATE, 0, 0, TRUE, TRUE);

 return TRUE;
}

可以看到在LoadFrame中主要做了2件事，第一，注册窗口。第二，创建窗口。先看AfxDeferRegisterClass()，它是一个全局函数，在文件AFXIMPL.H中可以看到

#define AfxDeferRegisterClass(fClass) AfxEndDeferRegisterClass(fClass)

在WINCORE.CPP中可以追踪到AfxEndDeferRegisterClass(fClass)如下：

BOOL AFXAPI AfxEndDeferRegisterClass(LONG fToRegister)
{
 // mask off all classes that are already registered
 AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
 fToRegister &= ~pModuleState->m_fRegisteredClasses;
 if (fToRegister == 0)
  return TRUE;

 LONG fRegisteredClasses = 0;

 // common initialization
 WNDCLASS wndcls;
 memset(&wndcls, 0, sizeof(WNDCLASS));   // start with NULL defaults
 wndcls.lpfnWndProc = DefWindowProc;
 wndcls.hInstance = AfxGetInstanceHandle();
 wndcls.hCursor = afxData.hcurArrow;

 INITCOMMONCONTROLSEX init;
 init.dwSize = sizeof(init);

 // work to register classes as specified by fToRegister, populate fRegisteredClasses as we go
 if (fToRegister & AFX_WND_REG)
 {
  // Child windows - no brush, no icon, safest default class styles
  wndcls.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
  wndcls.lpszClassName = _afxWnd;
  if (AfxRegisterClass(&wndcls))
   fRegisteredClasses |= AFX_WND_REG;
 }
 if (fToRegister & AFX_WNDOLECONTROL_REG)
 {
  // OLE Control windows - use parent DC for speed
  wndcls.style |= CS_PARENTDC | CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
  wndcls.lpszClassName = _afxWndOleControl;
  if (AfxRegisterClass(&wndcls))
   fRegisteredClasses |= AFX_WNDOLECONTROL_REG;
 }
 if (fToRegister & AFX_WNDCONTROLBAR_REG)
 {
  // Control bar windows
  wndcls.style = 0;   // control bars don't handle double click
  wndcls.lpszClassName = _afxWndControlBar;
  wndcls.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
  if (AfxRegisterClass(&wndcls))
   fRegisteredClasses |= AFX_WNDCONTROLBAR_REG;
 }
 if (fToRegister & AFX_WNDMDIFRAME_REG)
 {
  // MDI Frame window (also used for splitter window)
  wndcls.style = CS_DBLCLKS;
  wndcls.hbrBackground = NULL;
  if (_AfxRegisterWithIcon(&wndcls, _afxWndMDIFrame, AFX_IDI_STD_MDIFRAME))
   fRegisteredClasses |= AFX_WNDMDIFRAME_REG;
 }
 if (fToRegister & AFX_WNDFRAMEORVIEW_REG)
 {
  // SDI Frame or MDI Child windows or views - normal colors
  wndcls.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
  wndcls.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
  if (_AfxRegisterWithIcon(&wndcls, _afxWndFrameOrView, AFX_IDI_STD_FRAME))
   fRegisteredClasses |= AFX_WNDFRAMEORVIEW_REG;
 }
 if (fToRegister & AFX_WNDCOMMCTLS_REG)
 {
  // this flag is compatible with the old InitCommonControls() API
  init.dwICC = ICC_WIN95_CLASSES;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WIN95CTLS_MASK);
  fToRegister &= ~AFX_WIN95CTLS_MASK;
 }
 if (fToRegister & AFX_WNDCOMMCTL_UPDOWN_REG)
 {
  init.dwICC = ICC_UPDOWN_CLASS;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_UPDOWN_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_TREEVIEW_REG)
 {
  init.dwICC = ICC_TREEVIEW_CLASSES;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_TREEVIEW_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_TAB_REG)
 {
  init.dwICC = ICC_TAB_CLASSES;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_TAB_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_PROGRESS_REG)
 {
  init.dwICC = ICC_PROGRESS_CLASS;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_PROGRESS_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_LISTVIEW_REG)
 {
  init.dwICC = ICC_LISTVIEW_CLASSES;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_LISTVIEW_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_HOTKEY_REG)
 {
  init.dwICC = ICC_HOTKEY_CLASS;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_HOTKEY_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_BAR_REG)
 {
  init.dwICC = ICC_BAR_CLASSES;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_BAR_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_ANIMATE_REG)
 {
  init.dwICC = ICC_ANIMATE_CLASS;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_ANIMATE_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_INTERNET_REG)
 {
  init.dwICC = ICC_INTERNET_CLASSES;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_INTERNET_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_COOL_REG)
 {
  init.dwICC = ICC_COOL_CLASSES;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_COOL_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_USEREX_REG)
 {
  init.dwICC = ICC_USEREX_CLASSES;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_USEREX_REG);
 }
 if (fToRegister & AFX_WNDCOMMCTL_DATE_REG)
 {
  init.dwICC = ICC_DATE_CLASSES;
  fRegisteredClasses |= _AfxInitCommonControls(&init, AFX_WNDCOMMCTL_DATE_REG);
 }

 // save new state of registered controls
 pModuleState->m_fRegisteredClasses |= fRegisteredClasses;

 // special case for all common controls registered, turn on AFX_WNDCOMMCTLS_REG
 if ((pModuleState->m_fRegisteredClasses & AFX_WIN95CTLS_MASK) == AFX_WIN95CTLS_MASK)
 {
  pModuleState->m_fRegisteredClasses |= AFX_WNDCOMMCTLS_REG;
  fRegisteredClasses |= AFX_WNDCOMMCTLS_REG;
 }

 // must have registered at least as mamy classes as requested
 return (fToRegister & fRegisteredClasses) == fToRegister;
}

至此可以看到MFC默认的注册了很多窗口类，而其中调用了AfxRegisterClass函数。而AfxRegisterClass函数实现如下：

BOOL AFXAPI AfxRegisterClass(WNDCLASS* lpWndClass)
{
 WNDCLASS wndcls;
 if (GetClassInfo(lpWndClass->hInstance, lpWndClass->lpszClassName,
  &wndcls))
 {
  // class already registered
  return TRUE;
 }

 if (!::RegisterClass(lpWndClass))
 {
  TRACE1("Can't register window class named %s/n",
   lpWndClass->lpszClassName);
  return FALSE;
 }

 if (afxContextIsDLL)
 {
  AfxLockGlobals(CRIT_REGCLASSLIST);
  TRY
  {
   // class registered successfully, add to registered list
   AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
   LPTSTR lpszUnregisterList = pModuleState->m_szUnregisterList;
   // the buffer is of fixed size -- ensure that it does not overflow
   ASSERT(lstrlen(lpszUnregisterList) + 1 +
    lstrlen(lpWndClass->lpszClassName) + 1 <
    _countof(pModuleState->m_szUnregisterList));
   // append classname + newline to m_szUnregisterList
   lstrcat(lpszUnregisterList, lpWndClass->lpszClassName);
   TCHAR szTemp[2];
   szTemp[0] = '/n';
   szTemp[1] = '/0';
   lstrcat(lpszUnregisterList, szTemp);
  }
  CATCH_ALL(e)
  {
   AfxUnlockGlobals(CRIT_REGCLASSLIST);
   THROW_LAST();
   // Note: DELETE_EXCEPTION not required.
  }
  END_CATCH_ALL
  AfxUnlockGlobals(CRIT_REGCLASSLIST);
 }

 return TRUE;
}

可以看到最终调用Windows API函数实现窗口类的注册。

再次回到CFrameWnd::LoadFrame()函数，接下来就是产生窗口的操作了。LoadFrame中的Create调用依据多态性，应调用派生类的Create函数，由于派生类没有改写，此处调用CFrameWnd的Create函数。如下（在WINFRM.CPP中）：

BOOL CFrameWnd::Create(LPCTSTR lpszClassName,
 LPCTSTR lpszWindowName,
 DWORD dwStyle,
 const RECT& rect,
 CWnd* pParentWnd,
 LPCTSTR lpszMenuName,
 DWORD dwExStyle,
 CCreateContext* pContext)
{
 HMENU hMenu = NULL;
 if (lpszMenuName != NULL)
 {
  // load in a menu that will get destroyed when window gets destroyed
  HINSTANCE hInst = AfxFindResourceHandle(lpszMenuName, RT_MENU);
  if ((hMenu = ::LoadMenu(hInst, lpszMenuName)) == NULL)
  {
   TRACE0("Warning: failed to load menu for CFrameWnd./n");
   PostNcDestroy();            // perhaps delete the C++ object
   return FALSE;
  }
 }

 m_strTitle = lpszWindowName;    // save title for later

 if (!CreateEx(dwExStyle, lpszClassName, lpszWindowName, dwStyle,
  rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
  pParentWnd->GetSafeHwnd(), hMenu, (LPVOID)pContext))
 {
  TRACE0("Warning: failed to create CFrameWnd./n");
  if (hMenu != NULL)
   DestroyMenu(hMenu);
  return FALSE;
 }

 return TRUE;
}

后者又调用了CreateEx函数，CWnd有CreateEx函数，而CFrameWnd函数并没有改写它，故调用CWnd类的CreateEx函数，在WINCORE.cpp中实现如下：

BOOL CWnd::CreateEx(DWORD dwExStyle, LPCTSTR lpszClassName,
 LPCTSTR lpszWindowName, DWORD dwStyle,
 int x, int y, int nWidth, int nHeight,
 HWND hWndParent, HMENU nIDorHMenu, LPVOID lpParam)
{
 // allow modification of several common create parameters
 CREATESTRUCT cs;
 cs.dwExStyle = dwExStyle;
 cs.lpszClass = lpszClassName;
 cs.lpszName = lpszWindowName;
 cs.style = dwStyle;
 cs.x = x;
 cs.y = y;
 cs.cx = nWidth;
 cs.cy = nHeight;
 cs.hwndParent = hWndParent;
 cs.hMenu = nIDorHMenu;
 cs.hInstance = AfxGetInstanceHandle();
 cs.lpCreateParams = lpParam;

 if (!PreCreateWindow(cs))
 {
  PostNcDestroy();
  return FALSE;
 }

 AfxHookWindowCreate(this);
 HWND hWnd = ::CreateWindowEx(cs.dwExStyle, cs.lpszClass,
   cs.lpszName, cs.style, cs.x, cs.y, cs.cx, cs.cy,
   cs.hwndParent, cs.hMenu, cs.hInstance, cs.lpCreateParams);//Windows API完成窗口类的一些额外风格设置

#ifdef _DEBUG
 if (hWnd == NULL)
 {
  TRACE1("Warning: Window creation failed: GetLastError returns 0x%8.8X/n",
   GetLastError());
 }
#endif

 if (!AfxUnhookWindowCreate())
  PostNcDestroy();        // cleanup if CreateWindowEx fails too soon

 if (hWnd == NULL)
  return FALSE;
 ASSERT(hWnd == m_hWnd); // should have been set in send msg hook
 return TRUE;
}

该函数先是调用PreCreateWindow函数，依据多态性，先调用派生类，接着是CMDIFrameWnd,然后是CFrameWnd的PreCreateWindow函数

在WINFRM.CPP中如下：

BOOL CFrameWnd::PreCreateWindow(CREATESTRUCT& cs)
{
 if (cs.lpszClass == NULL)
 {
  VERIFY(AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG));
  cs.lpszClass = _afxWndFrameOrView;  // COLOR_WINDOW background
 }

 if ((cs.style & FWS_ADDTOTITLE) && afxData.bWin4)
  cs.style |= FWS_PREFIXTITLE;

 if (afxData.bWin4)
  cs.dwExStyle |= WS_EX_CLIENTEDGE;

 return TRUE;
}

沿着AfxDeferRegisterClass追踪下去，和上面的相同，都为MFC注册窗口类。

追踪完毕，回到开始的InitInstance函数中，接下来就是ShowWindow、UpdateWindow了。UpdateWindow会发出WM_PAINT消息。

再回到AfxWinMain（）函数就是调用pApp->Run()函数了。因为派生类没有改写所以调用CWinApp::Run()函数，在APPCORE.CPP中实现如下：

 

而CWinThread::Run实现如下，在文件THRDCORE.CPP中：

 

而CWinThread::PumpMessage实现如下：

 

可以看到都是调用底层Windows API实现。程序退出时回到AfxWinInit最后调用AfxWinTerm终止程序。

 

而消息映射的实现是利用钩子函数在AfxWndProc中实现的，最后没有处理的消息都用DefWindowProc函数处理

 

最后，本来要附上几张图片例子的，却不知如何在csdn上插入图片，杯具。也罢，放我163博客吧！

 

keyouan2008
关注
专栏目录
深入跟踪MFC程序的执行流程
ljianhui的专栏
04-10 8899
在MFC程序设计的学习过程中最令人感到难受，甚至于有时会动摇学习者信心的就是一种对于程序的一切细节都没有控制权的感觉。这种感觉来源于学习者不知道一个MFC程序是如何运行起来的（即一个MFC程序的执行流程）和MFC程序的设计思想和机制，即使是写过Windows程序的学习者，也会感到非常迷惘并且无从下手。而这种感觉的出现会使大家认为自己离开了书本上的例子就无法设计编制程序。下面我就来说一说一个MFC具
MFC程序的来龙去脉
周小宇的专栏
12-08 804
引言 ： 　　侯捷老师在他那本著名的"深入浅出MFC"（第二版）的第六章中对比着传统的Win32API编程，详细讲解了MFC应用程序“生死因果”，而且侯捷 老师还在"深入浅出MFC"（第二版）一书的“无责任书评”中称应用程序和MFC Framework的因果关系，是学习MFC程序设计的关键，并把它作为学习MFC程序设计的"第一个台阶".  正文 ： 　　初学MFC程序设计的人（甚至包
mfc来龙去脉
vb515927516的专栏
12-21 430
1.基本知识       MFC的程序如何运行,第一件事情就是找出MFC程序的进入点.MFC程序也是Windows程序.所以它应该也有一个WinMain.但在程序中好象看不到..     在程序进入点之前,还有一个(而且仅有一个)全局对象,这就是所谓的application object,当操作系统将程序加载并激活时,这个全局对象获得配置,其构造函数会先执行,比WinMain更早.所以先看
【原创】MFC程序设计之来龙去脉
程序的江湖？！ 勿在浮砂筑高台！
02-18 3620
 MFC程序设计             之来龙去脉 题记：前些日子一直想写这个东西，做了一个开头放在我的BLOG上(但是名为)，到后来就没有再管了，其实那只是冰山一角.具体MFC是怎么运行的，还是没有交待清楚，虽然自己的BLOG很少有人光顾，但是本着做事儿就要做到底的心态，继续完成该文。 说明：1、本文作者在VS2003中跟踪代码，此代码为VS2003中拷贝，使用MFC7。       2、不同
MFC学习日记一：MFC内部运行原理
万里独行
02-16 2489
Windows编程主线： 设计窗口类 注册窗口类 产生窗口 显示窗口 更新窗口 做消息循环 将消息路由到窗口中去处理 WinMain函数是所有程序的入口函数 Mfc的WinMain函数是当我们编译链接的时候编译器将WinMain链接到程序当中了 WinMain函数是在Msdn安装的位置的MFC文件夹下SRC目录下APPMODUL.CPP里就有_tWinMain它是一个宏右击它选
MFC程序运行所需库
06-30
标题“MFC程序运行所需库”指的是在运行MFC编写的程序时，必须依赖的一些关键库文件。这些库文件提供了运行MFC程序的基础框架和功能，如果缺失，程序可能会出现运行失败、崩溃或者无法启动等问题。描述中提到的“没...
MFC运行库（MFC程序运行所需动态库）
01-23
MFC运行库，即MFC程序运行所需动态库，是指在运行MFC编写的程序时，系统必须加载的一系列DLL（动态链接库）文件。这些DLL文件包含了MFC类库的实现，使得程序能够调用MFC的功能进行工作。常见的MFC运行库有msvcrt.dll...
MFC来龙去脉
10-13
### MFC来龙去脉：深入理解MFC框架与Windows编程 #### MFC的历史与背景 MFC（Microsoft Foundation Classes）是微软为简化Windows应用程序开发而设计的一套类库，它基于C++语言，提供了对Windows API的封装，使得...
深入浅出MFC - MFC来龙去脉
11-01
一本让你明白MFC来龙去脉的好书，作者甚至用最简单的C代码构建一个MFC系统，让你更直观明白很多原理性的东东。
简单追踪弹代码（MFC实现）
02-23
在IT行业中，尤其是在软件开发领域，追踪弹代码是一种常见的调试技术，它可以帮助开发者实时监控程序运行过程中的关键信息，如变量变化、函数调用等。本篇主要关注如何使用MFC（Microsoft Foundation Classes）框架...
从新手小白入门MFC框架视频精讲
01-30
微软基础类库（英语：Microsoft Foundation Classes，简称MFC）是微软公司提供的一个类库（class libraries），以C++类的形式封装了Windows API，并且包含一个应用程序框架，以减少应用程序开发人员的工作量。其中包含大量Windows句柄封装类和很多Windows的内建控件和组件的封装类！
CFormView不能WM_INITIALUPDATE消息的原因
最新发布
sannianji的专栏
05-26 131
CSingleDocTemplate::OpenDocumentFile和CDocument* CMultiDocTemplate::OpenDocumentFile中调用CDocTemplate::InitialUpdateFrame。例如非文档单视图中代码如下就能发送WM_INITIALUPDATE。
用 MFC 类库编程实现工作者线程
songyimin1208的博客
01-03 352
例程5 MultiThread5      为了与Win32 API对照，我们使用MFC 类库编程实现例程3 MultiThread3。      建立一个基于对话框的工程MultiThread5，在对话框IDD_MULTITHREAD5_DIALOG中加入一个编辑框 IDC_MILLISECOND，一个按钮IDC_START，标题为“开始” ，一个进度条IDC_PROGRESS1；   
温故而知新，学习MFC框架如何创建的过程
10-10 845
很久没有使用MFC了，以至于都忘记MFC框架复杂的窗口、文档、视的创建过程了。下面我们跟踪一个MFC MDI的应用程序，来温习或学习一下。 使用AppWizard创建一个MDI应用程序，我创建的应用程序叫MDITest，这样MFC生成了如下的类： 类名
MFC的入口函数（main函数）
热门推荐
daizhiyan1的博客
10-11 1万+
其实想看MFC的main函数，打开任一用MFC开发的App，设一个断点，然后查看调用堆栈。拉到最底部（即最先开始调用的东西） 在appmodul.cpp中可以看到如下代码： // This is a part of the Microsoft Foundation Classes C++ library. // Copyright (C) Microsoft Corporation // A...
MFC的模块状态：从AfxGetApp()和AFX_MANAGE_STATE()看MFC的模块状态
collecte的专栏
02-22 803
当我们在用MFC编程的时候，我们经常用到AfxGetApp()来获得当前的CWinApp的Instance。看看MFC的源代码中AfxGetApp()的实现，你会发现AfxGetApp()的实现并不像一般情况下面那样直接：_AFXWIN_INLINE CWinApp* AFXAPI AfxGetApp()         { return afxCurrentWinApp; }#def
MFC六大核心机制——初始化
suifengTYZ的专栏
11-25 2157
本人也是新手初学MFC（从Win32过渡过来），总结一下我的理解分享给大家，希望能产生共鸣。 要求：会点C++，知道基本关键字和类；至少能大概看明白一个简单的Win32应用程序。 先来手敲一个最简单的MFC程序： #include &lt;afxwin.h&gt; class CMyApp :public CWinApp { public: virtual BOOL InitInstance...
MFC程序的生死因果
嵌入式开发小站
09-27 1147
 程序的诞生：■ Application object 产生，内存于是获得配置，初值亦设立了。■ Afx WinMain 执行AfxWinInit，后者又调用AfxInitThread，把消息队列尽量加大到96。■ Afx WinMain 执行InitApplication。这是CWinApp 的虚拟函数，但我们通常不改写它。■ AfxWinMain 执行InitInsta
MFC程序运行顺序解析
"MFC的运行顺序" 在深入探讨MFC程序的运行顺序之前，我们需要了解MFC（Microsoft Foundation Classes）是微软为Windows应用程序开发提供的一套类库，它基于C++，并且封装了Windows SDK API，使得开发者能够更加方便...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值