Win32开发流程（完整）

╰+攻爆jí腚メ 2022-08-01 03:11 243阅读 0赞

编写一个Win32应用程序的大致流程，不管你的程序有多么复杂，多么变态，其基本思路和流程是不变的。这就好比你写书法的时候，特别是写楷书，我不管你用的是欧体、颜体，还是柳体，你都得遵守“永字八法”基本规则。

那么，我们要编写一个Win32应用程序，要经过哪几个步骤呢？

你不妨想一想，你有一家工厂是生产女性服装的，如果你要生产一批新式服装（例如某种冬装），你会有哪些流程？

首先，如果我们确定要做这么一款服式，我们要请设计师来把服装设计好，然后打版，打版就是生成基本样本，以后工人就按照这个样本做就行了。

其次，注册产品，向上级主管申报，登记后就转入车间或下游加工企业开工。

再次，为了展示你的新产品的特色，你要举办一场服装表演。

接着、持续更新，发现产品存在的问题，不断改进修正。

最后，推向市场。

我们开发Win32应用程序也是遵守这样的规范。不过，我想现在很少人用Win32在实际开发中，毕竟它的开发效率是相当地低下，所以，曾被某些人误认为只适用于开发木马程序。其实，也不一定的，不要太邪恶了。

MFC对Win API函数的封装，后来出现了托管C++，你可以用于写WinForm程序，这样可以提高开发效率。

如果你有足够的时间，如果你还在学习编程，如果你是刚进入大学的年轻有为者，你不用急，因为你会有更多的时间磨炼，你应当考虑多学一点C类语言，C++的学习你会发现你能学到很多其他语言中学不到的知识，特别是接触到不少原理性的东西，能加深你对编程哲学的认知。

## 一、WinMain入口点 ##

我们在学习标准C++的时候，都知道每个应用程序运行时都会先进入入口点函数main，而当从main函数跳出时程序就结束了。在Windows编程里面，也是一样的，只是我们的入口点函数不叫main，叫WinMain，这个函数不同于main，我们不能乱来，它的定义必须与声明保持一致。

我建议各位安装VS的时候，都顺便更新帮助文档到本地硬盘，这样我们可以方便查找。有一点要注意，目前DestTop Develop的文档基本上是英文的，做好心理准备。

WinMain函数怎么写呢，不用记的，到MSDN文档一搜，直接复制就行了。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **int** CALLBACK WinMain( 
2.   \_In\_ **HINSTANCE** hInstance, 
3.   \_In\_ **HINSTANCE** hPrevInstance, 
4.   \_In\_ **LPSTR** lpCmdLine, 
5.   \_In\_ **int** nCmdShow 
6.   );

这个函数带了一个CALLBACK，说明它是一个回调函数，那么这个CALLBACK是啥呢。我们先不管，我们先动写一个Windows，让大家有一个更直观的认识。

1、启动你的开发工具，版本任意。

2、从菜单栏中依次【文件】【新建】【项目】，在新建项目窗口中，选择Win32-Win32应用程序。

![1358042038_3663.PNG][]

2、点击确定后，会弹出一个向导，单击【下一步】。项目类型选择Windows应用程序，附加选项选择空项目，我们要自己编写实现代码。

![1358042213_2192.PNG][]

3、单击完成，项目创建成功。打开【解决方案资源管理器】，在“源文件”文件夹上右击，从菜单中找到【添加】【新建项】，注意，是源文件，不要搞到头文件去了。

在新建项窗口中选C++代码文件，.cpp后缀的，不要选错了，选成头文件，不然无法编译，因为头文件是不参与编译的。文件名随便。

包含Windows.h头文件，这个是最基本的。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1. \#include <Windows.h>

然后是入口点，这个我们直接把MSDN的声明Ctrl + C，然后Ctrl + V上去就行了。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **int** CALLBACK WinMain( 
2.   \_In\_ **HINSTANCE** hInstance, 
3.   \_In\_ **HINSTANCE** hPrevInstance, 
4.   \_In\_ **LPSTR** lpCmdLine, 
5.   \_In\_ **int** nCmdShow 
6.   ) 
7.  \{ 
8.  
9.  **return** 0; 
10. \}

WinMain返回整型，返回0就行了，其实是进程的退出码，一定要0，不要写其他，因为0表示正常退出，其他值表示非正常退出。

刚才我们提到这个函数带了CALLBACK，那么，它是什么？很简单，你回到IDE，在CALLBACK上右击，选【转到定义】，看看吧。

我们看到它其实是一个宏，原型如下：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define CALLBACK \_\_stdcall

这时候我们发现了，它其实就是\_\_stdcall，那么这个\_\_stdcall是什么呢？它是和\_\_cdecl关键字对应的，这些资料，你网上搜一下就有了，如果你觉得不好理解，你不妨这样认为，\_\_stdcall是专门用来调用Win API 的，反正MSDN上也是这样说的，它其实是遵循Pascal的语法调用标准，相对应地，\_\_cdecl是C语言的调用风格，这个也是编译器选项。  
打开项目属性，找到节点C/C++\\高级，然后查看一下调用约定，我们看到默认是选择C风格调用的，所以，WIN API 函数才用上关键字\_\_stdcall，如果你实在不懂，也没关系，这个东西一般不影响我们写代码，但属性窗口中的编译器选项不要乱改，改掉了可能会导致一些问题。

![1358043457_4531.PNG][]

那么CALLBACK有什么特别呢？一句话：函数不是我们调用的，但函数只定义了模型没有具体处理，而代码处理权在被调用者手里。怎么说呢，我们完全把它理解为.NET中的委托，我想这样就好理解了，委托只声明了方法的参数和返回值，并没有具体处理代码。

WinMain是由系统调用的，而WinMain中的代码如何写，那操作系统就不管了。就好像我告诉你明天有聚会，一起去爬山，反正我是通知你了，至于去不去那是你决定了。

接下来看看入口点函数的参数。

注意，我们平时看到很多如HANDLE，HINSTANCE，HBRUSH，WPARAM。LPARAM，HICON，HWND等一大串数据类型，也许我们会说，怎么Windows开发有那么多数据类型。其实你错了，人总是被眼睛所看到的东西欺骗，Win API 中根本没有什么新的数据类型，全都是标准C++中的类型，说白了，这些东西全是数字来的。如果你不信，自己可以研究一下。

它定义这些名字，只是方便使用罢了，比如下面这样：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **int** hWindow; 
2.  **int** hIcon; 
3.  **int** theAppInstance;

第一个变量指的是窗口的句柄，第二个指的是一个图标的句柄，第三个是当前应用程序的实例句柄，你看看，如果我们所有的句柄都是int，我们就无法判断那些类型是专门用来表示光标资源，不知道哪些类型是专用来表示位图的句柄了，但是，如果我们这样：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#defin HBRUSH int64

这样就很直观，我一看这名就知道是Brush Handlers，哦，我就明白它是专门用来管理内存中的画刷资源的，看，这就很明了，所以，通常这些新定义的类型或者宏，都是取有意义的名字。比如消息，它也是一个数字，如果我说115代表叫你去滚，但光是一个115谁知道你什么意思，但是，如果我们为它定义一个宏：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#define WM\_GET\_OUT 115

这样，只要我SendMessage(hwnd, WM\_GET\_OUT, NULL, NULL)，你就会收到一条消息，滚到一边去。

WinMain的第一个参数是当前应用程序的实例句柄，第二个参数是前一个实例，比如我把kill.exe运行了两个实例，进程列表中会有两个kill.exe，这时候第一次运行的实例号假设为0001，就传递第一个参数hInstance，第二次运行的假设实例号为0002，就传给了hPrevInstance参数。

lpCmdLine参数从名字上就猜到了，就是命令行参数，那LPSTR是啥呢，它其实就是一个字符串，你可以跟入定义就知道了，它其实就是char\*，指向char的指针，记得我上一篇文章中说的指针有创建数组的功能吗？对，其实这里传入的命令行参数应该是char\[ \]，这就是我在第一篇文章中要说指针的原因。

这里告诉大家一个技巧，我们怎么知道哪些参数是指针类型呢，因为不是所有参数都有 \* 标识。技巧还是在命名上，以后，***只要我们看到P开头的，或者LP开头的，都是指针类型***。

比如LPWSTR，LPCTSTR，LPRECT等等。

最后一个参数nCmdShow是主窗口的显示方式。它定义了以下宏。

<table style="color:rgb(51,51,51); font-family:Arial; font-size:14px; line-height:26px"> 
 <tbody> 
 <tr> 
 <th>Value</th> 
 <th>Meaning</th> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_HIDE 0 
 </dl> </td> 
 <td> Hides the window and activates another window. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_MAXIMIZE 3 
 </dl> </td> 
 <td> Maximizes the specified window. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_MINIMIZE 6 
 </dl> </td> 
 <td> Minimizes the specified window and activates the next top-level window in the Z order. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_RESTORE 9 
 </dl> </td> 
 <td> Activates and displays the window. If the window is minimized or maximized, the system restores it to its original size and position. An application should specify this flag when restoring a minimized window. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_SHOW 5 
 </dl> </td> 
 <td> Activates the window and displays it in its current size and position. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_SHOWMAXIMIZED 3 
 </dl> </td> 
 <td> Activates the window and displays it as a maximized window. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_SHOWMINIMIZED 2 
 </dl> </td> 
 <td> Activates the window and displays it as a minimized window. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_SHOWMINNOACTIVE 7 
 </dl> </td> 
 <td> Displays the window as a minimized window. This value is similar toSW_SHOWMINIMIZED, except the window is not activated. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_SHOWNA 8 
 </dl> </td> 
 <td> Displays the window in its current size and position. This value is similar toSW_SHOW, except the window is not activated. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_SHOWNOACTIVATE 4 
 </dl> </td> 
 <td> Displays a window in its most recent size and position. This value is similar toSW_SHOWNORMAL, except the window is not activated. </td> 
 </tr> 
 <tr> 
 <td><a style="color:rgb(51,102,153)" rel="nofollow"></a><a style="color:rgb(51,102,153)" rel="nofollow"></a> 
 <dl> 
 SW_SHOWNORMAL 1 
 </dl> </td> 
 <td> Activates and displays a window. If the window is minimized or maximized, the system restores it to its original size and position. An application should specify this flag when displaying the window for the first time. </td> 
 </tr> 
 </tbody> 
</table>

这个参数是操作系统传入的，我们无法修改它。那么，应用程序在运行时，是如何决定这个参数的呢？看看这个，不用我介绍了吧，你一定很熟悉。

![1358045582_3583.PNG][]

我们写了WinMain，但我们还要在WinMain前面预先定义一个WindowProc函数。C++与C\#，Java这些语言不同，你只需记住，C++编译器的解析是从左到右，从上到下的，如果某函数要放到代码后面来实现，但在此之前要使用，那么你必须先声明一下，不然编译时会找不到。这里因为我们通常会把WindowProc实现放在WinMain之后，但是在WinMain中设计窗口类时要用到它的指针，这时候，我们必须在WinMain之前声明WindowProc。

同样地，WindowProc的定义我们不用记，到MSDN直接抄就行了。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

前导声明与后面实现的函数的签名必须一致，编译才会认为它们是同一个函数。在WindowProc中返回DefWindowProc是把我们不感兴趣或者没有处理的消息交回给操作系统来处理。也许你会问，函数的名字一定要叫WindowProc吗？当然不是了，你可以改为其他名字，如MyProc，但前提是返回值和参数的类型以及个数必须一致。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **LRESULT** CALLBACK MyProc( 
2.   \_In\_ **HWND** hwnd, 
3.   \_In\_ **UINT** uMsg, 
4.   \_In\_ **WPARAM** wParam, 
5.   \_In\_ **LPARAM** lParam 
6.  )

这个函数带了CALLBACK，说明不是我们调用的，也是由操作系统调用的，我们在这个函数里面对需要处理的消息进行响应。至于，为什么可以改函数的名字而系统为什么能找到这个函数呢，后面你就知道了。

## 二、设计与注册窗口类 ##

设计窗口类，其实就是设计我们程序的主窗口，如有没有标题栏，背景什么颜色，有没有边框，可不可以调整大小等。要设计窗口类，我们用到一个结构——

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **typedef****struct** tagWNDCLASS \{ 
2.  **UINT** style; 
3.   WNDPROC lpfnWndProc; 
4.  **int** cbClsExtra; 
5.  **int** cbWndExtra; 
6.  **HINSTANCE** hInstance; 
7.  **HICON** hIcon; 
8.  **HCURSOR** hCursor; 
9.  **HBRUSH** hbrBackground; 
10. **LPCTSTR** lpszMenuName; 
11. **LPCTSTR** lpszClassName; 
12. \} WNDCLASS, \*PWNDCLASS;

通常情况下，我们用WNDCLASS就可以了，当然还有一个WNDCLASSEX的扩展结构，在API里面，凡是看到EX结尾的都是扩展的意思，比如CreateWindowEx就是CreateWindow的扩展函数。

第一个成员是窗口的类样式，注意，不要和窗口样式（WS\_xxxxx）混淆了，这里指的是这个窗口类的特征，不是窗口的外观特征，这两个style是不一样的。

它的值可以参考MSDN，通常我们只需要两个就可以了——**CS\_HREDRAW** | **CS\_VREDRAW**，从名字就看出来了，就是同时具备水平重画和垂直重画。因为当我们的窗口显示的时候，被其他窗口挡住后重新显示，或者大小调整后，窗口都要发生绘制，就像我们在纸上涂鸦一样，每次窗口的变化都会“粉刷”一遍，并发送WM\_PAINT消息。

lpfnWndProc参数就是用来设置你用哪个WindowProc来处理消息，前面我说过，我们只要不更改回调函数的返回值和参数的类型和顺序，就可以随意设置函数的名字，那为什么系统可以找到我们用的回调函数呢，对的，就是通过lpfnWndProc传进去的，它是一个函数指针，也就是它里面保存的是我们定义的WindowProc的入口地址，使用很简单，我们只需要把函数的名字传给它就可以了。

cbClsExtra和cbWndExtra通常不需要，设为0就OK。hInstance是当前应用程序的实例句柄，从WinMain的hInstance参数中可以得到。hIcon和hCursor就不用我说了，看名字就知道了。

hbrBackground是窗口的背景色，你也可以不设置，但在处理WM\_PAINT消息时必须绘制窗口背景。也可以直接用系统定义的颜色，MSDN为我们列出这些值，大家不用记，直接到MSDN拿来用就行了，这些都比较好理解，看名字就知道了。

*  COLOR\_ACTIVEBORDER
 *  COLOR\_ACTIVECAPTION
 *  COLOR\_APPWORKSPACE
 *  COLOR\_BACKGROUND
 *  COLOR\_BTNFACE
 *  COLOR\_BTNSHADOW
 *  COLOR\_BTNTEXT
 *  COLOR\_CAPTIONTEXT
 *  COLOR\_GRAYTEXT
 *  COLOR\_HIGHLIGHT
 *  COLOR\_HIGHLIGHTTEXT
 *  COLOR\_INACTIVEBORDER
 *  COLOR\_INACTIVECAPTION
 *  COLOR\_MENU
 *  COLOR\_MENUTEXT
 *  COLOR\_SCROLLBAR
 *  COLOR\_WINDOW /\* 这个就是窗口的默认背景色 \*/
 *  COLOR\_WINDOWFRAME
 *  COLOR\_WINDOWTEXT

lpszMenuName指的是菜单的ID，没有菜单就NULL，lpszClassName就是我们要向系统注册的类名，字符，不能与系统已存在的类名冲突，如“BUTTON”类。

所以，在WinMain中设计窗口类。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 类名
2.  **WCHAR**\* cls\_Name = L"My Class"; 
3.  // 设计窗口类
4.  WNDCLASS wc; 
5.  wc.hbrBackground = (**HBRUSH**)COLOR\_WINDOW; 
6.  wc.lpfnWndProc = WindowProc; 
7.  wc.lpszClassName = cls\_Name; 
8.  wc.hInstance = hInstance;

窗口类设计完成后，不要忘了向系统注册，这样系统才能知道有这个窗口类的存在。向操作系统注册窗口类，使用RegisterClass函数，它的参数就是一个指向WNDCLASS结构体的指针，所以我们传递的时候，要加上&符号。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 注册窗口类
2.  RegisterClass(&wc);

## 三、创建和显示窗口 ##

窗口类注册完成后，就应该创建窗口，然后显示窗口，调用CreateWindow创建窗口，如果成功，会返回一个窗口的句柄，我们对这个窗口的操作都要用到这个句柄。什么是句柄呢？其实它就是一串数字，只是一个标识而已，内存中会存在各种资源，如图标、文本等，为了可以有效标识这些资源，每一个资源都有其唯一的标识符，这样，通过查找标识符，就可以知道某个资源存在于内存中哪一块地址中，就好比你出身的时候，长辈都要为你取个名字，你说名字用来干吗？名字就是用来标识你的，不然，你见到A叫小明，遇到B又叫小明，那谁知道哪个才是小明啊？就好像你上大学去报到号，会为你分配一个可以在本校学生中唯一标识你的学号，所有学生的学号都是不同的，这样，只要通过索引学号，就可以找到你的资料。

CreateWindow函数返回一个HWND类型，它就是窗口类的句柄。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 创建窗口
2.  **HWND** hwnd = CreateWindow( 
3.   cls\_Name, //类名，要和刚才注册的一致
4.   L"我的应用程序", //窗口标题文字
5.   WS\_OVERLAPPEDWINDOW, //窗口外观样式
6.   38, //窗口相对于父级的X坐标
7.   20, //窗口相对于父级的Y坐标
8.   480, //窗口的宽度
9.   250, //窗口的高度
10.  NULL, //没有父窗口，为NULL
11.  NULL, //没有菜单，为NULL
12.  hInstance, //当前应用程序的实例句柄
13.  NULL); //没有附加数据，为NULL
14. **if**(hwnd == NULL) //检查窗口是否创建成功
15. **return** 0;

窗外观的样式都是WS\_打头的，是Window Style的缩写，这个我就不说了，MSDN上全有了。

窗口创建后，就要显示它，就像我们的产品做了，要向客户展示。显示窗口调用ShowWindow函数。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 显示窗口
2.  ShowWindow(hwnd, SW\_SHOW);

既然要显示窗口了，那么ShowWindow的第一个参数就是刚才创建的窗口的句柄，第二个参数控制窗口如何显示，你可以从SW\_XXXX中选一个，也可以用WinMain传进来的参数，还记得WinMain的最后一个参数吗？

## 四、更新窗口（可选） ##

为什么更新窗口这一步可有可无呢？因为只要程序在运行着，只要不是最小化，只要窗口是可见的，那么，我们的应用程序会不断接收到WM\_PAINT通知。这里先不说，后面你会明白的。好了，更新窗口，当然是调用UpdateWindow函数。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 更新窗口
2.  UpdateWindow(hwnd);

## 五、消息循环 ##

Windows操作系统是基于消息控制机制的，用户与系统之间的交互，程序与系统之间的交互，都是通过发送和接收消息来完成的。就好像军队一样，命令一旦传达，就要执行，当然，我们的应用程序和军队不一样，我们收到指令不一要执行，我们是可以选择性地执行。

我们知道，代码是不断往前执行的，像我们刚才写的WinMain函数一样，如果你现在运行程序，你会发现什么都没有，是不是程序不能运行呢，不是，其实程序是运行了，只是它马上结束了，只要程序执行跳出了WinMain的右大括号，程序就会结束了。那么，要如何让程序不结束了，可能大家注意到我们在C程序中可以用一个getchar()函数来等到用户输入，这样程序就人停在那里，直到用户输入内容。但我们的窗口应用不能这样做，因为用户有可能进行其他操作，如最小化窗口，移动窗口，改变窗口大小，或者点击窗口上的按钮等。因此，我们不能简地弄一个getchar在那里，这样就无法响应用户的其他操作了。

可以让程序留在某处不结束的另一个方法就是使用循环，而且是死循环，这样程序才会永久地停在某个地方，但这个死循环必须具有跳出的条件，不然你的程序会永久执行，直达停电或者把电脑砸了。

这样消息循环就出现了，只要有与用户交互，系统人不断地向应用程序发送消息通知，因为这些消息是不定时不断发送的，必须有一个绶冲区来存放，就好像你去银行办理手续要排队一样，我们从最前端取出一条一条消息处理，后面新发送的消息会一直在排队，直到把所有消息处理完，这就是***消息队列***。  
  
要取出一条消息，调用GetMessage函数。函数会传入一个MSG结构体的指针，当收到消息，会填充MSG结构体中的成员变量，这样我们就知道我们的应用程序收到什么消息了，直到GetMessage函数取不到消息，条件不成立，循环跳出，这时应用程序就退出。MSG的定义如下：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **typedef****struct** tagMSG \{ 
2.  **HWND** hwnd; 
3.  **UINT** message; 
4.  **WPARAM** wParam; 
5.  **LPARAM** lParam; 
6.  **DWORD** time; 
7.   POINT pt; 
8.  \} MSG, \*PMSG, \*LPMSG;

hwnd不用说了，就是窗口句柄，哪个窗口的句柄？还记得WindowProc回调函数吗？你把这个函数交给了谁来处理，hwnd就是谁的句柄，比如我们上面的代码，我们是把WindowProc赋给了新注册的窗口类，并创建了主窗口，返回一个表示主窗口的句柄，所以，这里MSG中的hwnd指的就是我们的主窗口。

message就是我们接收到的消息，看到，它是一个数字，无符号整型，所以我们操作的所有消息都是数字来的。wParam和lParam是消息的附加参数，其实也是数值来的。通常，lParam指示消息的处理结果，不同消息的结果（返回值）不同，具体可参阅MSDN。

有了一个整型的值来表示消息，我们为什么还需要附加参数呢？你不妨想一下，如果接收一条WM\_LBUTTONDOWN消息，即鼠标左键按下时发送的通知消息，那么，我们不仅知道左键按下这件事，我们更感趣的是，鼠标在屏幕上的哪个坐标处按下左键，按了几下，这时候，你公凭一条WM\_LBUTTONDOWN消息是无法传递这么多消息的。可能我们需要把按下左键时的坐标放入wParam参数中；最典型的就是WM\_COMMAND消息，因为只要你使用菜单，点击按钮都会发送这样一条消息，那么我怎么知道用户点了哪个按钮呢？如果窗口中只有一个按钮，那好办，用户肯定单击了它，但是，如果窗口上有10个按钮呢？而每一个按钮被单击都会发送WM\_COMMAND消息，你能知道用户点击了哪个按钮吗？所以，我们要把用户点击了的那个按钮的句柄存到lParam参数中，这样一来，我们就可以判断出用户到底点击了哪个按钮了。

GetMessage函数声明如下：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **BOOL** WINAPI GetMessage( 
2.   \_Out\_ LPMSG lpMsg, 
3.   \_In\_opt\_ **HWND** hWnd, 
4.   \_In\_ **UINT** wMsgFilterMin, 
5.   \_In\_ **UINT** wMsgFilterMax 
6.  );

这个函数在定义时带了一个WINAPI，现在，按照前面我说的方法，你应该猜到，它就是一个宏，而真实的值是\_\_stdcall，前文中说过了。

第一个参数是以LP开头，还记得吗，我说过的，你应该想到它就是 MSG\* ，一个指向MSG结构的指针。第二个参数是句柄，通常我们用NULL，因为我们会捕捉整个应用程序的消息。后面两个参数是用来过滤消息的，指定哪个范围内的消息我接收，在此范围之外的消息我拒收，如果不过滤就全设为0.。返回值就不说了，自己看。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 消息循环
2.  MSG msg; 
3.  **while**(GetMessage(&msg, NULL, 0, 0)) 
4.  \{ 
5.   TranslateMessage(&msg); 
6.   DispatchMessage(&msg); 
7.  \}

TranslateMessage是用于转换按键信息的，因为键盘按下和弹起会发送WM\_KEYDOWN和WM\_KEYUP消息，但如果我们只想知道用户输了哪些字符，这个函数可以把这些消息转换为WM\_CHAR消息，它表示的就是键盘按下的那个键的字符，如“A”，这样我们处理起来就更方便了。

DispatchMessage函数是必须调用的，它的功能就相当于一根传送带，每收到一条消息，DispatchMessage函数负责把消息传到WindowProc让我们的代码来处理，如果不调用这个函数，我们定义的WindowProc就永远接收不到消息，你就不能做消息响应了，你的程序就只能从运行就开始死掉了，没有响应。

## 六、消息响应 ##

其实现在我们的应用程序是可以运行了，因为在WindowProc中我们调用了DefWindowProc，函数，消息我们不作任何处理，又把控制权路由回到操作系统来默认处理，所以，整个过程中，我们现在的消息循环是成立的，只不过我们不做任何响应罢了。

好的，现在我把完整的代码贴一下，方便你把前面我们说的内容串联起来。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1. \#include <Windows.h>
2. // 必须要进行前导声明
3. **LRESULT** CALLBACK WindowProc( 
4. \_In\_ **HWND** hwnd, 
5. \_In\_ **UINT** uMsg, 
6. \_In\_ **WPARAM** wParam, 
7. \_In\_ **LPARAM** lParam 
8. ); 
9. 
10. // 程序入口点
11. **int** CALLBACK WinMain( 
12. \_In\_ **HINSTANCE** hInstance, 
13. \_In\_ **HINSTANCE** hPrevInstance, 
14. \_In\_ **LPSTR** lpCmdLine, 
15. \_In\_ **int** nCmdShow 
16. ) 
17. \{ 
18. // 类名
19. **WCHAR**\* cls\_Name = L"My Class"; 
20. // 设计窗口类
21. WNDCLASS wc; 
22. wc.hbrBackground = (**HBRUSH**)COLOR\_WINDOW; 
23. wc.lpfnWndProc = WindowProc; 
24. wc.lpszClassName = cls\_Name; 
25. wc.hInstance = hInstance; 
26. // 注册窗口类
27. RegisterClass(&wc); 
28. 
29. // 创建窗口
30. **HWND** hwnd = CreateWindow( 
31. cls\_Name, //类名，要和刚才注册的一致
32. L"我的应用程序", //窗口标题文字
33. WS\_OVERLAPPEDWINDOW, //窗口外观样式
34. 38, //窗口相对于父级的X坐标
35. 20, //窗口相对于父级的Y坐标
36. 480, //窗口的宽度
37. 250, //窗口的高度
38. NULL, //没有父窗口，为NULL
39. NULL, //没有菜单，为NULL
40. hInstance, //当前应用程序的实例句柄
41. NULL); //没有附加数据，为NULL
42. **if**(hwnd == NULL) //检查窗口是否创建成功
43. **return** 0; 
44. 
45. // 显示窗口
46. ShowWindow(hwnd, SW\_SHOW); 
47. 
48. // 更新窗口
49. UpdateWindow(hwnd); 
50. 
51. // 消息循环
52. MSG msg; 
53. **while**(GetMessage(&msg, NULL, 0, 0)) 
54. \{ 
55. TranslateMessage(&msg); 
56. DispatchMessage(&msg); 
57. \} 
58. **return** 0; 
59. \} 
60. // 在WinMain后实现
61. **LRESULT** CALLBACK WindowProc( 
62. \_In\_ **HWND** hwnd, 
63. \_In\_ **UINT** uMsg, 
64. \_In\_ **WPARAM** wParam, 
65. \_In\_ **LPARAM** lParam 
66. ) 
67. \{ 
68. **return** DefWindowProc(hwnd, uMsg, wParam, lParam); 
69. \}

所有代码看上去貌似很正常，也遵守了流程，*设计窗口类，注册窗口类，创建窗口，显示窗口，更新窗口，消息循环*。是吧，这段代码看上去毫无破绽，运行应该没问题吧。好，如果你如此自信，那就试试吧。

按下F5试试运行。  
哈哈，结果会让很多人失望，很多初学者就是这样，一切看起来好像正常，于是有人开始骂VC是垃圾，是编译器有bug，也有人开始想放弃了，妈的，这么难，不学了。人啊，总是这样，老指责别人的问题，从不在自己身上找问题，是真的VC的bug吗？

我前面说了，这段代码貌似很正常，呵呵，你看到问题在哪吗？给你两分钟来找错。我提示一下，这个程序没有运行是因为主窗口根本就没有创建，因为我在代码里面做了判断，如果窗口顺柄hwnd为NULL，就退出，现在程序一运行就退出了，明显是窗口创建失败。

…………

好了，不用找了，很多人找不出来，尤其是许多初学者，不少人找了一遍又一遍，都说没有错误，至少代码提示没说有错，编译运行也没报错，所以不少人自信地说，代码没错。

其实你是对的，代码确实没有错，而问题就出在WNDCLASS结构上，认真看一下MSDN上有关RegisterClass函数说明中的一句话，这句话很多人没注意到，但它很关键。

*You must fill the structure with the appropriate class attributes before passing it to the function.*

现在你明白了吧，还不清楚？没关系，看看我把代码这样改一下你就知道了。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 设计窗口类
2.  WNDCLASS wc; 
3.  wc.cbClsExtra = 0; 
4.  wc.cbWndExtra = 0; 
5.  wc.hCursor = LoadCursor(hInstance, IDC\_ARROW);; 
6.  wc.hIcon = LoadIcon(hInstance, IDI\_APPLICATION);; 
7.  wc.lpszMenuName = NULL; 
8.  wc.style = CS\_HREDRAW | CS\_VREDRAW; 
9.  wc.hbrBackground = (**HBRUSH**)COLOR\_WINDOW; 
10. wc.lpfnWndProc = WindowProc; 
11. wc.lpszClassName = cls\_Name; 
12. wc.hInstance = hInstance;

现在，你运行一下，你一定能看到窗口。

但现在你对窗口无法进行操作，因为后续的代码还没完成。

为什么现在又可以了呢？MSDN那句话的意思就是说我们在注册窗口类之前必须填充WNDCLASS结构体，何为填充，就是要为结构的所有成员赋值，就算不需要你也要为它赋一个NULL或0，因为结构在创建时没有对成员进行初始化，这就**导致变量无法正确的分配内存**，最后注册失败。

那么，如果一个结构体成员很多，而我只需要用到其中三个，其他的也要初始化，是不是很麻烦，是的，除了为每个成员赋值，还有一种较简单的方法，就是在声明变量时给它赋一对大括号，里面放置结构体的应该分配内存的大小，如：

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 设计窗口类
2.  WNDCLASS wc = \{ **sizeof**(WNDCLASS) \}; 
3.  wc.hbrBackground = (**HBRUSH**)COLOR\_WINDOW; 
4.  wc.lpfnWndProc = WindowProc; 
5.  wc.lpszClassName = cls\_Name; 
6.  wc.hInstance = hInstance;

这样一来，我们也发现，窗口也可以成功创建。

我们还可以更简单，直接把sizeof也去掉，在声明变量时，直接赋一对空的大括号就行了，就如这样。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  WNDCLASS wc = \{ \};

这样写更简单，窗口类同样可以正常注册。大括号代表的是代码块，这样，结构体有了一个初值，因此它会按照结构体的大小分配了相应的内存。

为什么会这样呢？这里涉及到一个关于结构体的一个很有趣的赋值方式。我们先放下我们这个例子，下面我写一个简单的例子，你就明白了。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1. \#include <stdio.h>
2. **typedef****struct** rectStruct 
3. \{ 
4. **int** x; 
5. **int** y; 
6. **int** width; 
7. **int** height; 
8. \} RECT, \*PRECT; 
9. 
10. **void** main() 
11. \{ 
12. RECT rect = \{ 0, 0, 20, 30 \}; 
13. printf("矩形的坐标是：%d, %d\\n矩形的大小：%d , %d", rect.x, rect.y, rect.width, rect.height); 
14. getchar(); 
15. \}

在本例中，我们定义了一个表示矩形的结构体 RECT ，它有四个成员，分别横坐标，纵坐标，宽度，高度，但是，我们在声明和赋值中，我们只用了一对大括号，把每个成员的值，按照定义的顺序依次写到大括号中，即\{ 0, 0, 20, 30 \}，x的值为0，y的值为0，width为20，height的值为30。

也就是说，我们可以通过这种简单的方法向结构变量赋值，注意值的顺序要和成员变量定义的顺序相同。

现在，回到我们的Windows程序来，我们明白了这种赋值方式，对于 WNDCLASS wc = \{ \} 就不难理解了，这样虽然大括号里面是空的，其实它已经把变量初始化了，都赋了默认值，这样一来，就可以正确分配内存了。

## 七、为什么不能退出 ##

通常情况下，当我们的主窗口关闭后，应用程序应该退出（木马程序除外），但是，我们刚才运行后发现，为什么我的窗口关了，但程序不退出呢？前面我说了，要退出程序，就要先跳出消息循环，和关闭哪个窗口无关。因此，我们要解决两个问题：

1、如果跳出消息循环；

2、什么时候退出程序。

其实两个问题是可以合并到一起解决。

首先要知道，当窗口被关闭，为窗口所分配的内存会被销毁，同时，我们会收到一条WM\_DESTROY消息，因而，我们只要在收到这条消息时调用PostQuitMessage函数，这个函数提交一条WM\_QUIT消息，而在消息循环中，WM\_QUIT消息使GetMessage函数返回0，这样一来，GetMessage返回FALSE，就可以跳出消息循环了，这样应用程序就可以退出了。

所以，我们要做的就是捕捉WM\_DESTROY消息，然后PostQuitMessage.

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 在WinMain后实现
2.  **LRESULT** CALLBACK WindowProc( 
3.   \_In\_ **HWND** hwnd, 
4.   \_In\_ **UINT** uMsg, 
5.   \_In\_ **WPARAM** wParam, 
6.   \_In\_ **LPARAM** lParam 
7.  ) 
8.  \{ 
9.  **switch**(uMsg) 
10.  \{ 
11. **case** WM\_DESTROY: 
12.  \{ 
13.  PostQuitMessage(0); 
14. **return** 0; 
15.  \} 
16.  \} 
17. **return** DefWindowProc(hwnd, uMsg, wParam, lParam); 
18. \}

我们会收到很多消息，所以用switch判断一下是不是WM\_DESTROY消息，如果是，退出应用程序。

好了，这样，我们一个完整的Windows应用程序就做好了。

![1358065786_9340.png][]

下面是完整的代码清单。

**\[cpp\]** [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1. \#include <Windows.h>
2. // 必须要进行前导声明
3. **LRESULT** CALLBACK WindowProc( 
4. \_In\_ **HWND** hwnd, 
5. \_In\_ **UINT** uMsg, 
6. \_In\_ **WPARAM** wParam, 
7. \_In\_ **LPARAM** lParam 
8. ); 
9. 
10. // 程序入口点
11. **int** CALLBACK WinMain( 
12. \_In\_ **HINSTANCE** hInstance, 
13. \_In\_ **HINSTANCE** hPrevInstance, 
14. \_In\_ **LPSTR** lpCmdLine, 
15. \_In\_ **int** nCmdShow 
16. ) 
17. \{ 
18. // 类名
19. **WCHAR**\* cls\_Name = L"My Class"; 
20. // 设计窗口类
21. WNDCLASS wc = \{ \}; 
22. wc.hbrBackground = (**HBRUSH**)COLOR\_WINDOW; 
23. wc.lpfnWndProc = WindowProc; 
24. wc.lpszClassName = cls\_Name; 
25. wc.hInstance = hInstance; 
26. // 注册窗口类
27. RegisterClass(&wc); 
28. 
29. // 创建窗口
30. **HWND** hwnd = CreateWindow( 
31. cls\_Name, //类名，要和刚才注册的一致
32. L"我的应用程序", //窗口标题文字
33. WS\_OVERLAPPEDWINDOW, //窗口外观样式
34. 38, //窗口相对于父级的X坐标
35. 20, //窗口相对于父级的Y坐标
36. 480, //窗口的宽度
37. 250, //窗口的高度
38. NULL, //没有父窗口，为NULL
39. NULL, //没有菜单，为NULL
40. hInstance, //当前应用程序的实例句柄
41. NULL); //没有附加数据，为NULL
42. **if**(hwnd == NULL) //检查窗口是否创建成功
43. **return** 0; 
44. 
45. // 显示窗口
46. ShowWindow(hwnd, SW\_SHOW); 
47. 
48. // 更新窗口
49. UpdateWindow(hwnd); 
50. 
51. // 消息循环
52. MSG msg; 
53. **while**(GetMessage(&msg, NULL, 0, 0)) 
54. \{ 
55. TranslateMessage(&msg); 
56. DispatchMessage(&msg); 
57. \} 
58. **return** 0; 
59. \} 
60. // 在WinMain后实现
61. **LRESULT** CALLBACK WindowProc( 
62. \_In\_ **HWND** hwnd, 
63. \_In\_ **UINT** uMsg, 
64. \_In\_ **WPARAM** wParam, 
65. \_In\_ **LPARAM** lParam 
66. ) 
67. \{ 
68. **switch**(uMsg) 
69. \{ 
70. **case** WM\_DESTROY: 
71. \{ 
72. PostQuitMessage(0); 
73. **return** 0; 
74. \} 
75. \} 
76. **return** DefWindowProc(hwnd, uMsg, wParam, lParam); 
77. \} 
78.

[view plain]: http://blog.csdn.net/tcjiaan/article/details/8497535#
[1358042038_3663.PNG]: https://img-my.csdn.net/uploads/201301/13/1358042038_3663.PNG
[1358042213_2192.PNG]: https://img-my.csdn.net/uploads/201301/13/1358042213_2192.PNG
[1358043457_4531.PNG]: https://img-my.csdn.net/uploads/201301/13/1358043457_4531.PNG
[1358045582_3583.PNG]: https://img-my.csdn.net/uploads/201301/13/1358045582_3583.PNG
[1358065786_9340.png]: https://img-my.csdn.net/uploads/201301/13/1358065786_9340.png