读书笔记：windows程序设计

妖狐艹你老母 2022-05-26 06:56 185阅读 0赞

windows.h是一个最重要的包含文件，囊括若干其他头文件。下面是一些最基本的头文件：WINDEF.H（基本数据类型定义），WINNT.H（支持Unicode的类型定义），WINBASE.H（内核函数），WINUSER.H（用户界面函数），WINGDI.H（图形设备接口函数）

每个Windows程序包含入口点函数（WinMain或wWinMain）:

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow);

*hInstance* is something called a "handle to an instance" or "handle to a module." The operating system uses this value to identify the executable (EXE) when it is loaded in memory. The instance handle is needed for certain Windows functions — for example, to load icons or bitmaps.

*hInstance*叫做实例句柄，操作系统用这个值来标识该程序。

*hPrevInstance* has no meaning. It was used in 16-bit Windows, but is now always zero.

*pCmdLine*  contains the command-line arguments as a Unicode string.

*pCmdLine是用来运行程序的命令行。*

*nCmdShow*  is a flag that says whether the main application window will be minimized, maximized, or shown normally.

*nCmdShow*用来指明程序最初如何显示：或正常显示，或最大化到全屏，或最小化显示在任务栏上。

The function returns an **int** value. The return value is not used by the operating system, but you can use the return value to convey a status code to some other program that you write.返回int类型值可以用于向其他程序传递状态码

**WINAPI** is the calling convention. A *calling convention* defines how a function receives parameters from the caller. For example, it defines the order that parameters appear on the stack.

WINDEF.H中用以下语句来定义WINAPI标识符：\#define WINAPI \_\_stdcall  这条语句规定了一种函数调用约定，表明如何生成在堆栈中放置函数调用参数的机器代码。

The **WinMain** function is identical to **wWinMain**, except the command-line arguments are passed as an ANSI string. The Unicode version is preferred. You can use the ANSI **WinMain** function even if you compile your program as Unicode. To get a Unicode copy of the command-line arguments, call the [GetCommandLine][] function. This function returns all of the arguments in a single string. If you want the arguments as an *argv*\-style array, pass this string to [CommandLineToArgvW][].

How does the compiler know to invoke wWinMain instead of the standard main function? What actually happens is that the Microsoft C runtime library (CRT) provides an implementation of main that calls either WinMain or wWinMain.

Note  The CRT does some additional work inside main. For example, any static initializers are called before wWinMain. Although you can tell the linker to use a different entry-point function, use the default if you link to the CRT. Otherwise, the CRT initialization code will be skipped, with unpredictable results. (For example, global objects will not be initialized correctly.)

#ifndef UNICODE
    #define UNICODE
    #endif 
    
    #include <windows.h>
    
    LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
    
    int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR pCmdLine, int nCmdShow)
    {
        // Register the window class.
        const wchar_t CLASS_NAME[]  = L"Sample Window Class";
        
        WNDCLASS wc = { };
    
        wc.lpfnWndProc   = WindowProc;
        wc.hInstance     = hInstance;
        wc.lpszClassName = CLASS_NAME;
    
        RegisterClass(&wc);
    
        // Create the window.
    
        HWND hwnd = CreateWindowEx(
            0,                              // Optional window styles.
            CLASS_NAME,                     // Window class
            L"Learn to Program Windows",    // Window text
            WS_OVERLAPPEDWINDOW,            // Window style
    
            // Size and position
            CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
    
            NULL,       // Parent window    
            NULL,       // Menu
            hInstance,  // Instance handle
            NULL        // Additional application data
            );
    
        if (hwnd == NULL)
        {
            return 0;
        }
    
        ShowWindow(hwnd, nCmdShow);
    
        // Run the message loop.
    
        MSG msg = { };
        while (GetMessage(&msg, NULL, 0, 0))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    
        return 0;
    }
    
    LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
        switch (uMsg)
        {
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    
        case WM_PAINT:
            {
                PAINTSTRUCT ps;
                HDC hdc = BeginPaint(hwnd, &ps);
    
                FillRect(hdc, &ps.rcPaint, (HBRUSH) (COLOR_WINDOW+1));
    
                EndPaint(hwnd, &ps);
            }
            return 0;
    
        }
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }

Notice that the progam does not explicitly call the WindowProc function, even though we said this is where most of the application logic is defined. Windows communicates with your program by passing it a series of  *messages* . The code inside the  **while**  loop drives this process. Each time the program calls the  [DispatchMessage][]  function, it indirectly causes Windows to invoke the WindowProc function, once for each message.

[GetCommandLine]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms683156%28v=vs.85%29.aspx
[CommandLineToArgvW]: https://msdn.microsoft.com/en-us/library/windows/desktop/bb776391%28v=vs.85%29.aspx
[DispatchMessage]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms644934%28v=vs.85%29.aspx