首页 > 代码库 > 基本的Windows应用程序 窗体创建

基本的Windows应用程序 窗体创建

2024-08-15 14:31:59   223人阅读

基本的Windows应用程序

 

转载：http://shiba.hpe.sh.cn/jiaoyanzu/WULI/Article1506

 

下面是一个完全可以运行的Windows程序，代码很简单，读者通过代码中的注释了解它们的含义。我们将在下一节详细讲解些代码。做为一个练习，我们建议读者在你的开发工具中创建一个工程，手工输入些代码，然后编译运行这个程序。注意，如果你使用的是Visual C++，那么在选择工程类型时必须是“Win32 application project”，而不能是“Win32 console application project”。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
// 包含Windows头文件；这个文件中包含所有Win32 API声明的
// 结构体、类型和函数，是使用Win32 API必须的基本条件。
#include <windows.h>
// 主窗口句柄；用于标示创建的窗体。
HWND ghMainWnd = 0;
// 封装了初始化一个Windows应用程序的代码。如果初始化成功则返回true，
// 否则则返回false。
bool InitWindowsApp(HINSTANCE instanceHandle,int show);
// 封装了消息循环的代码
int    Run();
// 消息处理函数用于处理窗口收到的消息。
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
// 在Windows中，WinMain相当于普通C++编程中的main函数
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
PSTR pCmdLine, int nShowCmd)
{
    // 首先调用InitWindowsApp函数创建并初始化主应用程序窗口，
    // 该函数的参数是hInstance和nShowCmd。
    if(!InitWindowsApp(hInstance, nShowCmd))
        return 0;
    // 之后进入消息循环，直到接收到WM_QUIT消息后才退出循环。
    return Run();
}
 
bool InitWindowsApp(HINSTANCE instanceHandle,int show)
{
    // 首先填写一个WNDCLASS结构体，描述窗口的基本属性。
    WNDCLASS wc;
    wc.style          = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc    = WndProc;
    wc.cbClsExtra      = 0;
    wc.cbWndExtra      = 0;
    wc.hInstance      = instanceHandle;
    wc.hIcon          = LoadIcon(0, IDI_APPLICATION);
    wc.hCursor        = LoadCursor(0, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName    = 0;
    wc.lpszClassName = L"BasicWndClass";
    // 然后注册这个WNDCLASS示例，这样就
    //  可以基于它创建一个窗口。
    if(!RegisterClass(&wc))
    {
        MessageBox(0, L"RegisterClass FAILED",0, 0);
        return false;
    }
    // 注册了WNDCLASS示例后，我们就可以使用CreateWindow方法创建一个窗口。
    // 这个方法返回一个指向新创建的窗口的句柄(HWND)。如果创建失败，这个
    // 句柄为零。我们使用这个HWND变量引用由Windows维护的主程序窗口。
    // 我们必须保存这个窗口句柄，因为许多API函数都要求传入窗口句柄，明确所要操纵的窗口对象。
    ghMainWnd = CreateWindow(
        L"BasicWndClass",      // Registered WNDCLASS instance to use.
        L"Win32Basic",          // window title
        WS_OVERLAPPEDWINDOW,    // style flags
        CW_USEDEFAULT,          // x-coordinate
        CW_USEDEFAULT,          // y-coordinate
        CW_USEDEFAULT,          // width
        CW_USEDEFAULT,          // height
        0,                      // parent window
        0,                      // menu handle
        instanceHandle,        // app instance
        0);                    // extra creationparameters
    if(ghMainWnd == 0)
    {
        MessageBox(0, L"CreateWindow FAILED", 0, 0);
        return false;
    }
    // 最后一步是使用下面的两个函数显示并更新新创建的窗口。
    // 将刚刚创建的窗口句柄传递给这两个函数，使Windows知道要显示和更新哪个窗口。
    ShowWindow(ghMainWnd, show);
    UpdateWindow(ghMainWnd);
    return true;
}
 
int Run()
{
    MSG msg = {0};
    // 直到接收到WM_QUIT消息才会退出循环。当收到一个WM_QUIT消息时，
    // GetMessage函数会返回0，并退出循环。当出现错误时，
    // GetMessage函数会返回−1。注意,若没有收到消息，
    // GetMessage方法会让线程进入休眠状态。
    BOOL bRet = 1;
    while( (bRet = GetMessage(&msg, 0, 0, 0)) != 0)
    {
        if(bRet == -1)
        {
            MessageBox(0, L"GetMessage FAILED",L"Error", MB_OK);
            break;
        }
        else
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    return (int)msg.wParam;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    // 处理指定的消息。注意，若自己处理消息，就必须返回0。
    switch( msg)
    {
        // 点击鼠标左键，显示一个消息框。
        case WM_LBUTTONDOWN:
            MessageBox(0, L"Hello, World", L"Hello", MB_OK);
            return 0;
        // 当按下Escape时，会销毁主程序窗口
        case WM_KEYDOWN:
            if( wParam == VK_ESCAPE)
                DestroyWindow(ghMainWnd);
            return 0;
        // 接收到WM_DESTROY消息后，发送退出信息，终止消息循环。
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }
    // 将前面未处理的其他信息发送到默认的信息处理程序。
    // 注意，这个程序返回的是DefWindowProc的返回值。
    return DefWindowProc(hWnd, msg, wParam, lParam);
}

技术分享图 A.3：上述程序的屏幕截图。注意，当鼠标单击窗口客户区时会弹出一个消息框。还可以试着按下ESC键退出程序。

A.3 程序解析

我们将按照从上到下的顺序分析些代码，依次讲解遇到的每个函数。读者在阅读以下几节的过程中，可以时常参照上面列出的代码。

A.3.1 头文件、全局变量和函数原型

我们要做的第一件事情是包含windows.h头文件，获得windows.h头文件中声明的结构体、类型和函数，是使用Win32 API必须的基本条件。

?
1
#include <windows.h>

第二条语句定义了一个HWND类型的全局变量，该类型用于表示“窗口句柄”。在Windows编程中，我们经常使用句柄来引用那些由Windows内部维护的对象。在本例中，我们使用这个HWND变量引用由Windows维护的主程序窗口。我们必须保存这个窗口句柄，因为许多API函数都要求传入窗口句柄，明确所要操纵的窗口对象。例如，在调用UpdateWindow函数时需要传入一个HWND参数，指定所要刷新的窗口。如果我们不传入窗口句柄，那该函数就无法确定要刷新哪个窗口。

?
1
HWND ghMainWnd = 0;

下面的3行是函数声明。简单地说，InitWindowsApp负责创建和初始化主程序窗口， Run封装了程序的消息循环，WndProc是主窗口的消息处理函数。在随后的几个小节中，当我们调用些函数时，会对它们进行更为详细的分析和说明。

?
1
2
3
bool InitWindowsApp(HINSTANCE instanceHandle,int show);
int    Run();
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg,WPARAM wParam, LPARAM lParam);

A.3.2 WinMain

Windows中的WinMain函数与普通C++编程中的main函数的作用相同。WinMain函数的原型如下：

?
1
2
3
int WINAPI
WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
PSTR pCmdLine, int nShowCmd)

1．hInstance：当前应用程序的实例句柄。它是标识和引用当前应用程序的一种方式。记住，同一个Windows应用程序可能会并行运行多个实例（比如同时运行多个Microsoft Word实例），所以在引用某个特定实例时它非常有用。

2．hPrevInstance：该参数的值为0。它是16位Windows遗留下来的一个参数，Win32编程已不再使用。

3．pCmdLine：程序启动时传入的命令行参数字符串。

4．nShowCmd：指定应用程序窗口的显示方式。一些常用的值有：SW_SHOW（以当前的尺寸和位置显示窗口）、SW_SHOWMAXIMIZED（最大化）和SW_SHOWMINIMIZED（最小化）。要了解该参数的所有选项值，请参阅MSDN。如果WinMain函数调用成功，那么它将返回WM_QUIT消息的wParam成员。如果函数在未进入消息循环就已退出，那么它将返回0。标识符WINAPI的定义如下：

?
1
#define WINAPI __stdcall

它指定了函数的调用方式，即以何种方式处理堆栈上的函数参数。

A.3.3 WNDCLASS与注册

在WinMain中我们调用了函数InitWindowsApp。也许你能猜到，该函数用于完成程序的初始化工作。下面让我们进一步分析一下该函数的实现过程。InitWindowsApp返回一个bool值——当初始化成功时返回true，否则返回false。在WinMain函数中，我们为InitWindowsApp传入了应用程序的实例句柄hInstance和窗口的显示方式nShowCmd，这两个参数可以从WinMain的参数列表中得到。

?
1
if(!InitWindowsApp(hInstance, nShowCmd))

要初始化一个窗口，第一步是要填写一个WNDCLASS（window class，窗口类）结构体，描述窗口的基本属性。该结构体的定义如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
typedef struct _WNDCLASS{
    UINT      style;
    WNDPROC lpfnWndProc;
    int      cbClsExtra;
    int      cbWndExtra;
    HANDLE    hInstance;
    HICON    hIcon;
    HCURSOR hCursor;
    HBRUSH    hbrBackground;
    LPCTSTR lpszMenuName;
    LPCTSTR lpszClassName;
} WNDCLASS;

1．style：指定窗口类的样式。在本例中，我们使用了CS_HREDRAW和CS_VREDRAW的组合。这两个二进制位（bit）标志值表明当窗口的宽度或高度发生变化时，窗口将被重绘。要了解该参数的所有选项值，请参阅MSDN。

?
1
wc.style = CS_HREDRAW | CS_VREDRAW;

2．lpfnWndProc：与WNDCLASS关联的消息处理函数指针。窗口使用的消息处理函数完全由WNDCLASS中的这个参数决定。也就是说，如果我们使用同一个WNDCLASS来创建两个窗口，那么这两个窗口将使用同一个消息处理函数。反之，如果我们希望两个窗口使用不同的消息处理函数，那我们就必须定义两个不同的WNDCLASS实例，分别指定不同的消息处理函数。有关消息处理函数的内容请参见A.3.6 节。

?
1
wc.lpfnWndProc = WndProc;

3．cbClsExtra与cbWndExtra：用于存储附加数据。这两个参数通常不会用到，所以都设为0。

?
1
2
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;

4．hInstance：应用程序实例句柄。回顾前文，应用程序实例句柄是操作系统传给WinMain函数的第1个参数。

?
1
wc.hInstance = instanceHandle;

5．hIcon：用于指定显示在窗口标题栏上的图标。你可以自己设计图标，也可以使用Windows内置的几个图标；具体内容请参见MSDN。这里使用默认的应用程序图标：

?
1
wc.hIcon = LoadIcon(0, IDI_APPLICATION);

6．hCursor：用于指定鼠标位于窗口客户区时显示的光标。与hIcon类似，你可以自己设计光标，也可以使用Windows 内置的几个光标；具体内容请参见MSDN。这里使用标准的“箭头”光标：

?
1
wc.hCursor = LoadCursor(0, IDC_ARROW);

7．hbrBackground：用于指定窗口客户区的背景色。在本例中，我们调用Win32函数GetStockObject返回一个内置的白色画刷句柄；如果你想了解其他的内置画刷，请参见 MSDN。

?
1
wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

8．lpszMenuName：指定窗口菜单。由于我们的应用程序没有菜单， 所以将该参数设为 0。

?
1
wc.lpszMenuName = 0;

9．lpszClassName：指定窗口类的名称（也就是，为WNDCLASS实例起一个名字），任何有效的字符串都可以。在本例中，我们将它命名为“BasicWndClass”。在随后的代码中，我们将通过个名称来引用相应的WNDCLASS实例。

?
1
wc.lpszClassName = L"BasicWndClass";

随后，我们要调用RegisterClass函数把填好的WNDCLASS实例注册到Windows中。该函数接收一个指向WNDCLASS结构体的指针。在调用失败时返回0。

?
1
2
3
4
5
if(!RegisterClass(&wc))
{
    MessageBox(0, L"RegisterClass FAILED", 0, 0);
    return false;
}

A.3.4 创建和显示窗口

当我们把WNDCLASS实例注册到Windows系统之后，就可以依据该窗口类的描述来创建实际的窗口对象了。另外，我们可以通过窗口类的名字（lpszClassName）来引用注册后的WNDCLASS 实例。用于创建窗口对象的函数为CreateWindow，它的函数原型如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
HWND CreateWindow(
    LPCTSTR lpClassName,
    LPCTSTR lpWindowName,
    DWORD dwStyle,
    int x,
    int y,
    int nWidth,
    int nHeight,
    HWND hWndParent,
    HMENU hMenu,
    HANDLE hInstance,
    LPVOID lpParam
);

1．lpClassName：已注册的WNDCLASS实例的名字，该实例描述了所要创建的窗口对象的部分特征。

2．lpWindowName：窗口的名字；即显示在窗口标题栏上的字符串名称。

3．dwStyle：定义窗口的样式。WS_OVERLAPPEDWINDOW是以下几个标志值的组合：WS_OVERLAPPED、WS_CAPTION、WS_SYSMENU、WS_THICKFRAME、WS_MINIMIZEBOX和WS_MAXIMIZEBOX。这些标志值描述了所要创建的窗口的特征。 详情请参见MSDN。

4．x：窗口左上角在屏幕上的x坐标。可以将该参数设为CW_USEDEFAULT，Windows会为窗口选择一个适当的默认坐标值。

5．y：窗口左上角在屏幕上的y坐标。可以将该参数设为CW_USEDEFAULT，Windows会为窗口选择一个适当的默认坐标值。

6．nWidth：窗口宽度，单位为像素。可以将该参数设为CW_USEDEFAULT，Windows会为窗口选择一个适当的默认宽度。

7．nHeight：窗口高度，单位为像素。可以将该参数设为CW_USEDEFAULT，Windows会为窗口选择一个适当的默认高度。

8．hWndParent： 当前窗口的父窗口句柄。由于本例中的窗口没有任何父属窗口，所以该参数设为0。

9．hMenu：菜单句柄。由于本例中的窗口没有菜单，所以该参数设为0。

10．hInstance：与窗口关联的应用程序实例句柄。

11．lpParam：传递给WM_CREATE消息处理函数的用户自定义数据的指针。当创建窗口时，操作系统会向窗口发送一个WM_CREATE消息。该消息会在CreateWindow方法返回前发出。如果希望在创建窗口执行某些操作（比如，完成某些对象的初始化工作），那么就需要处理窗口的WM_CREATE消息。

注意：当我们为窗口指定x、y坐标时，这些坐标位置是相对于屏幕左上角的。而且，x轴的正方向水平向右，y轴的正方向垂直向下。

图A.4展示的坐标系称为屏幕坐标系（screen coordinate system），或屏幕空间（screen s图A.4展示的坐标系称为屏幕坐标系（screen coordinate system），或屏幕空间（screen space）。

技术分享图 A.4：屏幕空间。

CreateWindow函数将返回创建后的窗口句柄（一个HWND变量）。如果创建失败，则该句柄的值为0（空句柄）。记住，句柄是引用窗口的一种方式，而窗口由Windows来管理。许多API函数都要求传入窗口句柄，以明确所要操纵的窗口对象。

?
1
2
3
4
5
6
7
8
9
10
ghMainWnd = CreateWindow(L"BasicWndClass", L"Win32Basic",
    WS_OVERLAPPEDWINDOW,
    CW_USEDEFAULT, CW_USEDEFAULT,
    CW_USEDEFAULT, CW_USEDEFAULT,
    0, 0, instanceHandle, 0);
if(ghMainWnd == 0)
{
    MessageBox(0, L"CreateWindow FAILED", 0, 0);
    return false;
}

在InitWindowsApp中调用的最后两个函数用于控制窗口的显示。首先我们调用ShowWindow，并且将刚刚创建的窗口句柄传递给它，使Windows知道要显示哪个窗口。我们传入的另一个整数值表示窗口的初始显示状态（例如，最小化、最大化等等）。该值应设为nShowCmd（它是WinMain函数的第4个参数）。当初次显示窗口时，必须调用UpdateWindow方法，对窗口进行一次手动刷新。该函数只接收一个参数，指定所要刷新的窗口的句柄。

?
1
2
ShowWindow(ghMainWnd, show);
UpdateWindow(ghMainWnd);

到此为止，我们在InitWindowsApp函数中的初始化工作就已经完成了；如果一切顺利的话，该函数将返回true。

A.3.5 消息循环

在成功完成初始化工作之后，我们开始编写程序的核心部分——消息循环。在本例中， 我们将消息循环封装在了Run函数中。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int Run()
{
    MSG msg = {0};
    BOOL bRet = 1;
    while( (bRet = GetMessage(&msg, 0, 0, 0)) != 0)
    {
        if(bRet == -1)
        {
            MessageBox(0, L"GetMessage FAILED",L"Error", MB_OK);
            break;
        }
        else
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    return (int)msg.wParam;
}

在Run函数中做的第一件事情是声明一个MSG类型的变量msg。MSG是一个用于表示Windows 消息的结构体，它的原型如下：

?
1
2
3
4
5
6
7
8
typedef struct tagMSG {
    HWND hwnd;
    UINT message;
    WPARAM wParam;
    LPARAM lParam;
    DWORD time;
    POINT pt;
} MSG;

1．hwnd：接收消息的窗口的句柄。

2．message：用于标识特定消息的预定义常量值（例如，WM_QUIT）。

3．wParam：与消息相关的附加信息，参数的取值依具体消息而定。

4．lParam：与消息相关的附加信息，参数的取值依具体消息而定。

5．time：消息被送入消息队列时的时间。

6．pt：当消息被送入消息队列时，鼠标在屏幕空间中的x、y坐标。

随后，我们进入消息循环。GetMessage函数从消息队列中检索消息，使用消息的具体内容来填充msg参数。GetMessage函数的第2、3、4个参数均设为0。当出现错误时，GetMessage函数会返回−1。当收到一个WM_QUIT消息时，GetMessage函数会返回0，此时可以终止消息循环的运行。当GetMessage返回其他值时，需要调用另外两个函数：TranslateMessage和DispatchMessage。TranslateMessage用于进行某些键盘消息的转换；确切地说是将虚拟键盘码转换为字符信息。最后，DispatchMessage将消息分发给特定的消息处理函数。如果应用程序以WM_QUIT消息正常退出，那么WinMain函数应以WM_QUIT消息的wParam参数作为最终的返回值（退出码）。

A.3.6 消息处理函数

我们前面提到，消息处理函数（window procedure，直译为窗口过程）用于对窗口收到的消息做出响应，执行与当前消息对应的程序指令。在本例中，我们的消息处理函数为WndProc，其原型如下：

?
1
2
LRESULT CALLBACK
WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

该函数返回一个LRESULT（实际上是一个整数）值，表明函数的调用结果是成功还是失败。CALLBACK标识符说明该函数是一个回调函数（callback function），Windows将在应用程序的代码空间之外调用个函数。你可以从本例的源代码中看到，我们从未直接调用过个消息处理函数——当窗口需要处理一个消息时，Windows会替我们调用个函数。在消息处理函数的签名（signature）中包含4个参数：

1．hWnd：接收消息的窗口的句柄。

2．msg：用于标识特定消息的预定义常量值。例如，退出消息为WM_QUIT。前缀 WM 表示“window message （窗口消息）”。预定义的窗口消息有一百多个，具体请参见MSDN。

3．wParam：与消息相关的附加信息，参数的取值依具体消息而定。

4．lParam：与消息相关的附加信息，参数的取值依具体消息而定。

我们的消息处理函数处理了3个消息：WM_LBUTTONDOWN、WM_KEYDOWN和WM_DESTROY。WM_LBUTTONDOWN是用户在窗口客户区单击鼠标左键时发出的消息。WM_KEYDOWN是用户按下某个按键时发出的消息。WM_DESTROY是窗口被销毁时发出的消息。我们的代码相当简单；当窗口收到WM_LBUTTONDOWN消息时会弹出一个消息框，显示“Hello, World”字符串：

?
1
2
3
case WM_LBUTTONDOWN:
    MessageBox(0, L"Hello, World", L"Hello", MB_OK);
    return 0;

当窗口收到WM_KEYDOWN消息时，测试用户按下的是否为ESC键。如果是ESC键，我们就调用DestroyWindow函数销毁主程序窗口。此时传给消息处理函数的wParam参数包含了用户所按按键的虚拟键盘码。每个物理按键都有一个或多个与之对应的虚拟键盘码，它可以被视为物理按键在C++程序中的标识符。windows.h头文件包含了所有的虚拟键盘码常量，我们可以使用些常量来测试某一按键是否被按下；例如，我们可以使用虚拟键盘码常量VK_ESCAPE来测试ESC键是否被按下：

?
1
2
3
4
case WM_KEYDOWN:
    if( wParam == VK_ESCAPE)
        DestroyWindow(ghMainWnd);
    return 0;

记住，wParam和lParam参数用于指定消息的附加信息。对于WM_KEYDOWN消息来说，wParam参数包含了与按键对应的虚拟键盘码。MSDN详述了每个Windows消息的wParam和lParam参数含义。当窗口被销毁时，我们需要使用PostQuitMessage函数发送一个WM_QUIT消息（它将终止消息循环的运行）：

?
1
2
3
case WM_DESTROY:
    PostQuitMessage(0);
    return 0;

在我们的消息处理函数的最后，调用了DefWindowProc函数。该函数是默认的消息处理函数。在本例中，我们只处理了3个消息；其他所有的消息都按DefWindowProc函数中定义的默认行为来处理，我们不必亲自处理所有的消息。例如，本例中的最小化、最大化、窗口缩放和关闭功能都是由默认的消息处理函数来完成的，我们没有亲自处理些消息。

A.3.7 MessageBox函数

我们还有最后一个API函数没有讲解，也就是MessageBox函数。该函数可以非常方便地向用户显示提示信息，并获得一些简单的输入。MessageBox函数的原型如下：

?
1
2
3
4
5
6
int MessageBox(
    HWND hWnd,          // Handle of owner window, may specify null.
    LPCTSTR lpText,      // Text to put in the message box.
    LPCTSTR lpCaption, // Text for the title of the message box.
    UINT uType          // Style of the message box.
);

MessageBox函数的返回值取决于消息框的类型。要了解所有的返回值和消息框类型，请参见MSDN；图A.5展示了一种带有“Yes/No函数的返回值取决于消息框的类型。要了解所有的返回值和消息框类型，请参见MSDN；图A.5展示了一种带有“Yes/No”按钮的消息框。

技术分享图A.5：带有“Yes/No”按钮的消息框。

A.4 改进后的消息循环

游戏与传统的Windows应用程序之间有很大的区别。通常，游戏会主动重绘界面，不停地更新窗口，而不是坐等消息的到来。传统的消息循环会造成一个问题，当消息队列没有消息时，GetMessage函数会让线程进入休眠状态，等待消息到来。而在游戏中，我们不希望这种情况发生；当没有Windows 消息需要处理时，我们希望游戏运行自身的代码（比如，渲染3D场景、处理AI等等）。所以，我们要对消息循环做一些修改，用PeekMessage函数代替原先的GetMessage函数。PeekMessage函数会在没有消息时直接返回，不阻塞线程。我们改进后的消息循环如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int Run()
{
    MSG msg = {0};
     
    while(msg.message != WM_QUIT)
    {
        // If there are Window messages then process them.
        if(PeekMessage( &msg, 0, 0, 0, PM_REMOVE ))
        {
            TranslateMessage( &msg );
            DispatchMessage( &msg );
        }
        // Otherwise, do animation/game stuff.
        else
        {
        }
    }
    return (int)msg.wParam;
}

在声明msg变量之后，我们会进入了一个无限循环。我们首先调用API函数PeekMessage检查消息队列中是否存在消息。有关该函数的参数描述请参见 MSDN。如果消息队列中存在消息，则PeekMessage返回true，我们执行与先前同样的消息处理；反之，如果没有消息，则PeekMessage返回false，我们运行游戏自身的代码。

A.5 小结

1．在使用 Direct3D时，我们必须创建一个带有主窗口的Windows应用程序，在主窗口上渲染3D场景。而且，要为游戏创建一个特殊的消息循环。在有消息处理消息；在没有消息执行游戏自身的代码逻辑。

2．多个Windows应用程序可以并行运行，所以Windows必须管理那些由多个应用程序共享的资源，对应用程序产生的消息进行疏导。当一个事件（按键、鼠标单击、计时器等等）产生时，消息即被发送到应用程序的消息队列中。

3．每个Windows应用程序都有一个消息队列，用来存储应用程序收到的消息。应用程序的消息循环会不断地检查消息队列，当有消息出现时，它会把消息分发给相应的消息处理函数。注意，一个应用程序可以包含多个窗口。

4．消息处理函数是一个由我们自己编写的特殊的回调函数，当窗口收到消息时，Windows会自动调用与窗口对应的消息处理函数。在消息处理函数中，我们为特定的消息编写代码，使窗口在收到特定的消息执行相应的程序逻辑。对于那些未在消息处理函数中处理的消息，应转交给默认的消息处理函数来执行默认的行为。

 

基本的Windows应用程序 窗体创建


联系
我们