上一篇中我给各位说了一般人认为C++中较为难的东西——指针。其实对于C++，难点当然不局限在指针这玩意儿上，还有一些有趣的概念，如模板类、虚基类、纯虚函数等，这些都是概念性的东西，几乎每一本C++书上都会介绍，而平时我们除了会接触到纯虚函数外，其他的不多用。纯虚函数，你可以认为与C#中的抽象方法或接口中的方法类似，即只定义，不实现。好处就是多态，发何处理，由派生类来决定。
在开始吹牛之前，我先推荐一套视频教程，孙鑫老师的C++教程，共20课，我不是帮他老人家打广告，而是因为孙老师讲的课是我听过的最好的课，我都看过4次了，我完全可以用他的视频教程来复习C++的。
好了，F话说完了，下面我就扯一下编写一个Win32应用程序的大致流程，不管你的程序有多么复杂，多么变态，其基本思路和流程是不变的。这就好比你写书法的时候，特别是写楷书，我不管你用的是欧体、颜体，还是柳体，你都得遵守“永字八法”基本规则。
那么，我们要编写一个Win32应用程序，要经过哪几个步骤呢？
你不妨想一想，你有一家工厂是生产女性服装的，如果你要生产一批新式服装（例如某种冬装），你会有哪些流程？
首先，如果我们确定要做这么一款服式，我们要请设计师来把服装设计好，然后打版，打版就是生成基本样本，以后工人就按照这个样本做就行了。
其次，注册产品，向上级主管申报，登记后就转入车间或下游加工企业开工。
再次，为了展示你的新产品的特色，你要举办一场服装表演。
接着、持续更新，发现产品存在的问题，不断改进修正。
最后，推向市场。
我们开发Win32应用程序也是遵守这样的规范。不过，我想现在很少人用Win32在实际开发中，毕竟它的开发效率是相当地低下，所以，曾被某些人误认为只适用于开发木马程序。其实，也不一定的，不要太邪恶了。
MFC对Win API函数的封装，后来出现了托管C++，你可以用于写WinForm程序，这样可以提高开发效率。
如果你有足够的时间，如果你还在学习编程，如果你是刚进入大学的年轻有为者，你不用急，因为你会有更多的时间磨炼，你应当考虑多学一点C类语言，C++的学习你会发现你能学到很多其他语言中学不到的知识，特别是接触到不少原理性的东西，能加深你对编程哲学的认知。
一、WinMain入口点 我们在学习标准C++的时候，都知道每个应用程序运行时都会先进入入口点函数main，而当从main函数跳出时程序就结束了。在Windows编程里面，也是一样的，只是我们的入口点函数不叫main，叫WinMain，这个函数不同于main，我们不能乱来，它的定义必须与声明保持一致。
我建议各位安装VS的时候，都顺便更新帮助文档到本地硬盘，这样我们可以方便查找。有一点要注意，目前DestTop Develop的文档基本上是英文的，做好心理准备。
WinMain函数怎么写呢，不用记的，到MSDN文档一搜，直接复制就行了。
01.int CALLBACK WinMain(
02. _In_ HINSTANCE hInstance,
03. _In_ HINSTANCE hPrevInstance,
04. _In_ LPSTR lpCmdLine,
05. _In_ int nCmdShow
06. ); 复制代码这个函数带了一个CALLBACK，说明它是一个回调函数，那么这个CALLBACK是啥呢。我们先不管，我们先动写一个Windows，让大家有一个更直观的认识。
1、启动你的开发工具，版本任意。
2、从菜单栏中依次【文件】【新建】【项目】，在新建项目窗口中，选择Win32-Win32应用程序。
2、点击确定后，会弹出一个向导，单击【下一步】。项目类型选择Windows应用程序，附加选项选择空项目，我们要自己编写实现代码。 3、单击完成，项目创建成功。打开【解决方案资源管理器】，在“源文件”文件夹上右击，从菜单中找到【添加】【新建项】，注意，是源文件，不要搞到头文件去了。
在新建项窗口中选C++代码文件，.cpp后缀的，不要选错了，选成头文件，不然无法编译，因为头文件是不参与编译的。文件名随便。 包含Windows.h头文件，这个是最基本的。
#include <Windows.h>
然后是入口点，这个我们直接把MSDN的声明Ctrl + C，然后Ctrl + V上去就行了。
01.int CALLBACK WinMain(
02. _In_ HINSTANCE hInstance,
03. _In_ HINSTANCE hPrevInstance,
04. _In_ LPSTR lpCmdLine,
05. _In_ int nCmdShow
06. )
07.{
08.
09. return 0;
10.} 复制代码WinMain返回整型，返回0就行了，其实是进程的退出码，一定要0，不要写其他，因为0表示正常退出，其他值表示非正常退出。
刚才我们提到这个函数带了CALLBACK，那么，它是什么？很简单，你回到IDE，在CALLBACK上右击，选【转到定义】，看看吧。
我们看到它其实是一个宏，原型如下：
#define CALLBACK __stdcall 这时候我们发现了，它其实就是__stdcall，那么这个__stdcall是什么呢？它是和__cdecl关键字对应的，这些资料，你网上搜一下就有了，如果你觉得不好理解，你不妨这样认为，__stdcall是专门用来调用Win API 的，反正MSDN上也是这样说的，它其实是遵循Pascal的语法调用标准，相对应地，__cdecl是C语言的调用风格，这个也是编译器选项。 打开项目属性，找到节点C/C++高级，然后查看一下调用约定，我们看到默认是选择C风格调用的，所以，WIN API 函数才用上关键字__stdcall，如果你实在不懂，也没关系，这个东西一般不影响我们写代码，但属性窗口中的编译器选项不要乱改，改掉了可能会导致一些问题。 那么CALLBACK有什么特别呢？一句话：函数不是我们调用的，但函数只定义了模型没有具体处理，而代码处理权在被调用者手里。怎么说呢，我们完全把它理解为.NET中的委托，我想这样就好理解了，委托只声明了方法的参数和返回值，并没有具体处理代码。
WinMain是由系统调用的，而WinMain中的代码如何写，那操作系统就不管了。就好像我告诉你明天有聚会，一起去爬山，反正我是通知你了，至于去不去那是你决定了。
接下来看看入口点函数的参数。
注意，我们平时看到很多如HANDLE，HINSTANCE，HBRUSH，WPARAM。LPARAM，HICON，HWND等一大串数据类型，也许我们会说，怎么Windows开发有那么多数据类型。其实你错了，人总是被眼睛所看到的东西欺骗，Win API 中根本没有什么新的数据类型，全都是标准C++中的类型，说白了，这些东西全是数字来的。如果你不信，自己可以研究一下。
它定义这些名字，只是方便使用罢了，比如下面这样：
int hWindow; int hIcon; int theAppInstance; 第一个变量指的是窗口的句柄，第二个指的是一个图标的句柄，第三个是当前应用程序的实例句柄，你看看，如果我们所有的句柄都是int，我们就无法判断那些类型是专门用来表示光标资源，不知道哪些类型是专用来表示位图的句柄了，但是，如果我们这样：
#defin HBRUSH int64 这样就很直观，我一看这名就知道是Brush Handlers，哦，我就明白它是专门用来管理内存中的画刷资源的，看，这就很明了，所以，通常这些新定义的类型或者宏，都是取有意义的名字。比如消息，它也是一个数字，如果我说115代表叫你去滚，但光是一个115谁知道你什么意思，但是，如果我们为它定义一个宏：
#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是主窗口的显示方式。它定义了以下宏。
这个参数是操作系统传入的，我们无法修改它。那么，应用程序在运行时，是如何决定这个参数的呢？看看这个，不用我介绍了吧，你一定很熟悉。 我们写了WinMain，但我们还要在WinMain前面预先定义一个WindowProc函数。C++与C#，JAVA这些语言不同，你只需记住，C++编译器的解析是从左到右，从上到下的，如果某函数要放到代码后面来实现，但在此之前要使用，那么你必须先声明一下，不然编译时会找不到。这里因为我们通常会把WindowProc实现放在WinMain之后，但是在WinMain中设计窗口类时要用到它的指针，这时候，我们必须在WinMain之前声明WindowProc。
同样地，WindowProc的定义我们不用记，到MSDN直接抄就行了。
01.#include <Windows.h>
02.// 必须要进行前导声明
03.LRESULT CALLBACK WindowProc(
04. _In_ HWND hwnd,
05. _In_ UINT uMsg,
06. _In_ WPARAM wParam,
07. _In_ LPARAM lParam
08.);
09.
10.int CALLBACK WinMain(
11. _In_ HINSTANCE hInstance,
12. _In_ HINSTANCE hPrevInstance,
13. _In_ LPSTR lpCmdLine,
14. _In_ int nCmdShow
15. )
16.{
17. return 0;
18.}
19.// 在WinMain后实现
20.LRESULT CALLBACK WindowProc(
21. _In_ HWND hwnd,
22. _In_ UINT uMsg,
23. _In_ WPARAM wParam,
24. _In_ LPARAM lParam
25.)
26.{
27. return DefWindowProc(hwnd, uMsg, wParam, lParam);
28.}
29. 复制代码前导声明与后面实现的函数的签名必须一致，编译才会认为它们是同一个函数。在WindowProc中返回DefWindowProc是把我们不感兴趣或者没有处理的消息交回给操作系统来处理。也许你会问，函数的名字一定要叫WindowProc吗？当然不是了，你可以改为其他名字，如MyProc，但前提是返回值和参数的类型以及个数必须一致。
01.LRESULT CALLBACK MyProc(
02. _In_ HWND hwnd,
03. _In_ UINT uMsg,
04. _In_ WPARAM wParam,
05. _In_ LPARAM lParam
06.) 复制代码这个函数带了CALLBACK，说明不是我们调用的，也是由操作系统调用的，我们在这个函数里面对需要处理的消息进行响应。至于，为什么可以改函数的名字而系统为什么能找到这个函数呢，后面你就知道了。
二、设计与注册窗口类 设计窗口类，其实就是设计我们程序的主窗口，如有没有标题栏，背景什么颜色，有没有边框，可不可以调整大小等。要设计窗口类，我们用到一个结构——
01.typedef struct tagWNDCLASS {
02. UINT style;
03. WNDPROC lpfnWndProc;
04. int cbClsExtra;
05. int cbWndExtra;
06. HINSTANCE hInstance;
07. HICON hIcon;
08. HCURSOR hCursor;
09. 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拿来用就行了，这些都比较好理解，看名字就知道了。
01.COLOR_ACTIVEBORDER
02.COLOR_ACTIVECAPTION
03.COLOR_APPWORKSPACE
04.COLOR_BACKGROUND
05.COLOR_BTNFACE
06.COLOR_BTNSHADOW
07.COLOR_BTNTEXT
08.COLOR_CAPTIONTEXT
09.COLOR_GRAYTEXT
10.COLOR_HIGHLIGHT
11.COLOR_HIGHLIGHTTEXT
12.COLOR_INACTIVEBORDER
13.COLOR_INACTIVECAPTION
14.COLOR_MENU
15.COLOR_MENUTEXT
16.COLOR_SCROLLBAR
17.COLOR_WINDOW /* 这个就是窗口的默认背景色 */
18.COLOR_WINDOWFRAME
19.COLOR_WINDOWTEXT 复制代码lpszMenuName指的是菜单的ID，没有菜单就NULL，lpszClassName就是我们要向系统注册的类名，字符，不能与系统已存在的类名冲突，如“BUTTON”类。
所以，在WinMain中设计窗口类。
01.// 类名
02.WCHAR* cls_Name = L"My Class";
03.// 设计窗口类
04.WNDCLASS wc;
05.wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
06.wc.lpfnWndProc = WindowProc;
07.wc.lpszClassName = cls_Name;
08.wc.hInstance = hInstance; 复制代码窗口类设计完成后，不要忘了向系统注册，这样系统才能知道有这个窗口类的存在。向操作系统注册窗口类，使用RegisterClass函数，它的参数就是一个指向WNDCLASS结构体的指针，所以我们传递的时候，要加上&符号。
// 注册窗口类 RegisterClass(&wc);
三、创建和显示窗口 窗口类注册完成后，就应该创建窗口，然后显示窗口，调用CreateWindow创建窗口，如果成功，会返回一个窗口的句柄，我们对这个窗口的操作都要用到这个句柄。什么是句柄呢？其实它就是一串数字，只是一个标识而已，内存中会存在各种资源，如图标、文本等，为了可以有效标识这些资源，每一个资源都有其唯一的标识符，这样，通过查找标识符，就可以知道某个资源存在于内存中哪一块地址中，就好比你出身的时候，长辈都要为你取个名字，你说名字用来干吗？名字就是用来标识你的，不然，你见到A叫小明，遇到B又叫小明，那谁知道哪个才是小明啊？就好像你上大学去报到号，会为你分配一个可以在本校学生中唯一标识你的学号，所有学生的学号都是不同的，这样，只要通过索引学号，就可以找到你的资料。
CreateWindow函数返回一个HWND类型，它就是窗口类的句柄。
01.// 创建窗口
02.HWND hwnd = CreateWindow(
03. cls_Name, //类名，要和刚才注册的一致
04. L"我的应用程序", //窗口标题文字
05. WS_OVERLAPPEDWINDOW, //窗口外观样式
06. 38, //窗口相对于父级的X坐标
07. 20, //窗口相对于父级的Y坐标
08. 480, //窗口的宽度
09. 250, //窗口的高度
10. NULL, //没有父窗口，为NULL
11. NULL, //没有菜单，为NULL
12. hInstance, //当前应用程序的实例句柄
13. NULL); //没有附加数据，为NULL
14.if(hwnd == NULL) //检查窗口是否创建成功
15. return 0;
16. 复制代码窗外观的样式都是WS_打头的，是Window Style的缩写，这个我就不说了，MSDN上全有了。
窗口创建后，就要显示它，就像我们的产品做了，要向客户展示。显示窗口调用ShowWindow函数。
// 显示窗口 ShowWindow(hwnd, SW_SHOW); 既然要显示窗口了，那么ShowWindow的第一个参数就是刚才创建的窗口的句柄，第二个参数控制窗口如何显示，你可以从SW_XXXX中选一个，也可以用WinMain传进来的参数，还记得WinMain的最后一个参数吗？
四、更新窗口（可选） 为什么更新窗口这一步可有可无呢？因为只要程序在运行着，只要不是最小化，只要窗口是可见的，那么，我们的应用程序会不断接收到WM_PAINT通知。这里先不说，后面你会明白的。好了，更新窗口，当然是调用UpdateWindow函数。
// 更新窗口 UpdateWindow(hwnd);
五、消息循环 Windows操作系统是基于消息控制机制的，用户与系统之间的交互，程序与系统之间的交互，都是通过发送和接收消息来完成的。就好像军队一样，命令一旦传达，就要执行，当然，我们的应用程序和军队不一样，我们收到指令不一要执行，我们是可以选择性地执行。
我们知道，代码是不断往前执行的，像我们刚才写的WinMain函数一样，如果你现在运行程序，你会发现什么都没有，是不是程序不能运行呢，不是，其实程序是运行了，只是它马上结束了，只要程序执行跳出了WinMain的右大括号，程序就会结束了。那么，要如何让程序不结束了，可能大家注意到我们在C程序中可以用一个getchar()函数来等到用户输入，这样程序就人停在那里，直到用户输入内容。但我们的窗口应用不能这样做，因为用户有可能进行其他操作，如最小化窗口，移动窗口，改变窗口大小，或者点击窗口上的按钮等。因此，我们不能简地弄一个getchar在那里，这样就无法响应用户的其他操作了。
可以让程序留在某处不结束的另一个方法就是使用循环，而且是死循环，这样程序才会永久地停在某个地方，但这个死循环必须具有跳出的条件，不然你的程序会永久执行，直达停电或者把电脑砸了。
这样消息循环就出现了，只要有与用户交互，系统人不断地向应用程序发送消息通知，因为这些消息是不定时不断发送的，必须有一个绶冲区来存放，就好像你去银行办理手续要排队一样，我们从最前端取出一条一条消息处理，后面新发送的消息会一直在排队，直到把所有消息处理完，这就是消息队列。
要取出一条消息，调用GetMessage函数。函数会传入一个MSG结构体的指针，当收到消息，会填充MSG结构体中的成员变量，这样我们就知道我们的应用程序收到什么消息了，直到GetMessage函数取不到消息，条件不成立，循环跳出，这时应用程序就退出。MSG的定义如下：
01.typedef struct tagMSG {
02. HWND hwnd;
03. UINT message;
04. WPARAM wParam;
05. LPARAM lParam;
06. DWORD time;
07. POINT pt;
08.} 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函数声明如下：
01.BOOL WINAPI GetMessage(
02. _Out_ LPMSG lpMsg,
03. _In_opt_ HWND hWnd,
04. _In_ UINT wMsgFilterMin,
05. _In_ UINT wMsgFilterMax
06.); 复制代码这个函数在定义时带了一个WINAPI，现在，按照前面我说的方法，你应该猜到，它就是一个宏，而真实的值是__stdcall，前文中说过了。
第一个参数是以LP开头，还记得吗，我说过的，你应该想到它就是 MSG* ，一个指向MSG结构的指针。第二个参数是句柄，通常我们用NULL，因为我们会捕捉整个应用程序的消息。后面两个参数是用来过滤消息的，指定哪个范围内的消息我接收，在此范围之外的消息我拒收，如果不过滤就全设为0.。返回值就不说了，自己看。
01.// 消息循环
02.MSG msg;
03.while(GetMessage(&msg, NULL, 0, 0))
04.{
05. TranslateMessage(&msg);
06. DispatchMessage(&msg);
07.} 复制代码TranslateMessage是用于转换按键信息的，因为键盘按下和弹起会发送WM_KEYDOWN和WM_KEYUP消息，但如果我们只想知道用户输了哪些字符，这个函数可以把这些消息转换为WM_CHAR消息，它表示的就是键盘按下的那个键的字符，如“A”，这样我们处理起来就更方便了。
DispatchMessage函数是必须调用的，它的功能就相当于一根传送带，每收到一条消息，DispatchMessage函数负责把消息传到WindowProc让我们的代码来处理，如果不调用这个函数，我们定义的WindowProc就永远接收不到消息，你就不能做消息响应了，你的程序就只能从运行就开始死掉了，没有响应。
六、消息响应 其实现在我们的应用程序是可以运行了，因为在WindowProc中我们调用了DefWindowProc，函数，消息我们不作任何处理，又把控制权路由回到操作系统来默认处理，所以，整个过程中，我们现在的消息循环是成立的，只不过我们不做任何响应罢了。
好的，现在我把完整的代码贴一下，方便你把前面我们说的内容串联起来。
01.#include <Windows.h>
02.// 必须要进行前导声明
03.LRESULT CALLBACK WindowProc(
04. _In_ HWND hwnd,
05. _In_ UINT uMsg,
06. _In_ WPARAM wParam,
07. _In_ LPARAM lParam
08.);
09.
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.
现在你明白了吧，还不清楚？没关系，看看我把代码这样改一下你就知道了。
01.// 设计窗口类
02.WNDCLASS wc;
03.wc.cbClsExtra = 0;
04.wc.cbWndExtra = 0;
05.wc.hCursor = LoadCursor(hInstance, IDC_ARROW);;
06.wc.hIcon = LoadIcon(hInstance, IDI_APPLICATION);;
07.wc.lpszMenuName = NULL;
08.wc.style = CS_HREDRAW | CS_VREDRAW;
09.wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
10.wc.lpfnWndProc = WindowProc;
11.wc.lpszClassName = cls_Name;
12.wc.hInstance = hInstance; 复制代码现在，你运行一下，你一定能看到窗口。
但现在你对窗口无法进行操作，因为后续的代码还没完成。
为什么现在又可以了呢？MSDN那句话的意思就是说我们在注册窗口类之前必须填充WNDCLASS结构体，何为填充，就是要为结构的所有成员赋值，就算不需要你也要为它赋一个NULL或0，因为结构在创建时没有对成员进行初始化，这就导致变量无法正确的分配内存，最后注册失败。
那么，如果一个结构体成员很多，而我只需要用到其中三个，其他的也要初始化，是不是很麻烦，是的，除了为每个成员赋值，还有一种较简单的方法，就是在声明变量时给它赋一对大括号，里面放置结构体的应该分配内存的大小，如：
01.// 设计窗口类
02.WNDCLASS wc = { sizeof(WNDCLASS) };
03.wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
04.wc.lpfnWndProc = WindowProc;
05.wc.lpszClassName = cls_Name;
06.wc.hInstance = hInstance; 复制代码这样一来，我们也发现，窗口也可以成功创建。
我们还可以更简单，直接把sizeof也去掉，在声明变量时，直接赋一对空的大括号就行了，就如这样。
WNDCLASS wc = { }; 这样写更简单，窗口类同样可以正常注册。大括号代表的是代码块，这样，结构体有了一个初值，因此它会按照结构体的大小分配了相应的内存。
为什么会这样呢？这里涉及到一个关于结构体的一个很有趣的赋值方式。我们先放下我们这个例子，下面我写一个简单的例子，你就明白了。
01.#include <stdio.h>
02. typedef struct rectStruct
03. {
04. int x;
05. int y;
06. int width;
07. int height;
08. } RECT, *PRECT;
09.
10. void main()
11. {
12. RECT rect = { 0, 0, 20, 30 };
13. printf("矩形的坐标是：%d, %d 矩形的大小：%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.
// 在WinMain后实现
01.LRESULT CALLBACK WindowProc(
02. _In_ HWND hwnd,
03. _In_ UINT uMsg,
04. _In_ WPARAM wParam,
05. _In_ LPARAM lParam
06.)
07.{
08. switch(uMsg)
09. {
10. case WM_DESTROY:
11. {
12. PostQuitMessage(0);
13. return 0;
14. }
15. }
16. return DefWindowProc(hwnd, uMsg, wParam, lParam);
17.} 复制代码我们会收到很多消息，所以用switch判断一下是不是WM_DESTROY消息，如果是，退出应用程序。
好了，这样，我们一个完整的Windows应用程序就做好了。
下面是完整的代码清单。
01.#include <Windows.h>
02.// 必须要进行前导声明
03.LRESULT CALLBACK WindowProc(
04. _In_ HWND hwnd,
05. _In_ UINT uMsg,
06. _In_ WPARAM wParam,
07. _In_ LPARAM lParam
08.);
09.
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.} 复制代码 本文摘自: 编程十万个为什么(http://www.bcwhy.com) 详细出处请参考：http://www.bcwhy.com/forum.php?mod=viewthread&tid=17639