深入Windows内核——C++中的消息机制

《编程思想之消息机制》一文中我们讲了消息的相关概念和消息机制的模拟，本文将进一步聊聊C++中的消息机制。

从简单例子探析核心原理

在讲之前，我们先看一个简单例子：创建一个窗口和两个按钮，用来控制窗口的背景颜色。其效果如下：

图 2 ：效果图

Win32Test.h

#pragma once

#include <windows.h>
#include <atltypes.h>
#include <tchar.h>

//资源ID
#define ID_BUTTON_DRAW      1000
#define ID_BUTTON_SWEEP     1001

// 注册窗口类
ATOM AppRegisterClass(HINSTANCE hInstance);
// 初始化窗口
BOOL InitInstance(HINSTANCE, int);
// 消息处理函数(又叫窗口过程)
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
// (白色背景)按钮事件
void OnButtonWhite();
// (灰色背景)按钮事件
void OnButtonGray();
// 绘制事件
void OnDraw(HDC hdc);

Win32Test.cpp


#include "stdafx.h"
#include "Win32Test.h"

//字符数组长度
#define MAX_LOADSTRING 100

//全局变量
HINSTANCE hInst;                                            // 当前实例
TCHAR g_szTitle[MAX_LOADSTRING] = TEXT("Message process");  // 窗口标题
TCHAR g_szWindowClass[MAX_LOADSTRING] = TEXT("AppTest");    // 窗口类的名称
HWND g_hWnd;                                                // 窗口句柄
bool g_bWhite = false;                                      // 是否为白色背景

//WinMain入口函数
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
    // 注册窗口类
    if(!AppRegisterClass(hInstance))
    {
         return (FALSE);
    }
    // 初始化应用程序窗口
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    // 消息循环
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return (int) msg.wParam;
}

// 注册窗口类
ATOM AppRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(NULL, IDI_APPLICATION);
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = NULL;
    wcex.lpszClassName  = g_szWindowClass;
    wcex.hIconSm        = NULL;

    return RegisterClassEx(&wcex);
}

// 保存实例化句柄并创建主窗口
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // 保存handle到全局变量
   g_hWnd = CreateWindow(g_szWindowClass, g_szTitle, WS_OVERLAPPEDWINDOW, 0, 0, 400, 300, NULL, NULL, hInstance, NULL);
   // 创建按钮
   HWND hBtWhite = CreateWindowEx(0, L"Button", L"白色", WS_CHILD | WS_VISIBLE | BS_TEXT, 100, 100, 50, 20, g_hWnd, (HMENU)ID_BUTTON_DRAW, hInst, NULL);
   HWND hBtGray = CreateWindowEx(0, L"Button", L"灰色", WS_CHILD | WS_VISIBLE | BS_CENTER, 250, 100, 50, 20, g_hWnd, (HMENU)ID_BUTTON_SWEEP, hInst, NULL);

   if (!g_hWnd)
   {
      return FALSE;
   }
   ShowWindow(g_hWnd, nCmdShow);
   UpdateWindow(g_hWnd);

   return TRUE;
}

// (窗口)消息处理
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc;

    switch (message)
    {
    case WM_COMMAND:
        wmId    = LOWORD(wParam);
        //wmEvent = HIWORD(wParam);

        switch (wmId)
        {
        case ID_BUTTON_DRAW:
            OnButtonWhite();
            break;
        case ID_BUTTON_SWEEP:
            OnButtonGray();
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
        break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        OnDraw(hdc);
        EndPaint(hWnd, &ps);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

//事件处理

//按下hBtWhite时的事件
void OnButtonWhite()
{
    g_bWhite = true;
    InvalidateRect(g_hWnd, NULL, FALSE);    //刷新窗口
}

//按下hBtGray时的事件
void OnButtonGray()
{
    g_bWhite = false;
    InvalidateRect(g_hWnd, NULL, FALSE);    //刷新窗口
}

//绘制事件(每次刷新时重新绘制图像)
void OnDraw(HDC hdc)
{
    POINT oldPoint;
    SetViewportOrgEx(hdc, 0, 0, &oldPoint);
    RECT rcView;
    GetWindowRect(g_hWnd, &rcView); // 获得句柄的画布大小
    HBRUSH hbrWhite = (HBRUSH)GetStockObject(WHITE_BRUSH);
    HBRUSH hbrGray = (HBRUSH)GetStockObject(GRAY_BRUSH);
    if (g_bWhite)
    {
        FillRect(hdc, &rcView, hbrWhite);
    } else
    {
        FillRect(hdc, &rcView, hbrGray);
    }
    SetViewportOrgEx(hdc, oldPoint.x, oldPoint.y, NULL);
}

在上面这个例子中，消息的流经过程如下：

图 3 ：消息的流经过程

这与《编程思想之消息机制》中图1(消息机制原理)是相吻合的，这就是Windows消息机制的核心部分，也是Windows API开发的核心部分。Windows系统和Windows下的程序都是以消息为基础，以事件为驱动。

RegisterClassEx的作用是注册一个窗口，在调用CreateWindow创建一个窗口前必须向windows系统注册获惟一的标识。

while (GetMessage(&msg, NULL, 0, 0))
{
    TranslateMessage(&msg);
    DispatchMessage(&msg);
}

这个while循环就是消息循环，不断地从消息队列中获取消息，并通过DispatchMessage(&msg)将消息分发出去。消息队列是在Windows操作系统中定义的(我们无法看到对应定义的代码)，对于每一个正在执行的Windows应用程序,系统为其建立一个“消息队列”，即应用程序队列，用来存放该程序可能创建的各种窗口的消息。DispatchMessage会将消息传给窗口函数(即消息处理函数)去处理，也就是WndProc函数。WndProc是一个回调函数，在注册窗口时通过wcex.lpfnWndProc将其传给了操作系统，所以DispatchMessage分发消息后，操作系统会调用窗口函数(WndProc)去处理消息。关于回调函数可参考：回调函数。

每一个窗口都应该有一个函数负责消息处理，程序员必须负责设计这个所谓的窗口函数WndProc。LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) 中的四个参数就是消息的相关信息(消息来自的句柄、消息类型等)，函数中通过switch/case根据不同的消息类型分别进行不同的处理。在收到相应类型的消息之后，可调用相应的函数去处理，如OnButtonWhite、OnButtonGray、OnDraw，这就是事件处理的雏形。 在default中调用了DefWindowProc，DefWindowProc是操作系统定义的默认消息处理函数，这是因为所有的消息都必须被处理，应用程序不处理的消息需要交给操作系统处理。

消息的定义和类型

Windows消息都以WM_为前缀，意思是”Windows Message”，如WM_CREATE、WM_PAINT等。消息的定义如下：

typedef struct tagMsg
{
    HWND    hwnd;           //接受该消息的窗口句柄
    UINT    message;        //消息常量标识符，也就是我们通常所说的消息号
    WPARAM  wParam;         //32位消息的特定附加信息，确切含义依赖于消息值
    LPARAM  lParam;         //32位消息的特定附加信息，确切含义依赖于消息值
    DWORD   time;           //消息创建时的时间
    POINT   pt;             //消息创建时的鼠标/光标在屏幕坐标系中的位置
}MSG;

消息主要有三种类型：

1. 命令消息(WM_COMMAND)：命令消息是程序员需要程序做某些操作的命令。凡UI对象产生的消息都是这种命令消息，可能来自菜单、加速键或工具栏按钮等，都以WM_COMMAND呈现。

2. 标准窗口消息：除WM_COMMAND之处，任何以WM_开头的消息都是这一类。标准窗口消息是系统中最为常见的消息，它是指由操作系统和控制其他窗口的窗口所使用的消息。例如CreateWindow、DestroyWindow和MoveWindow等都会激发窗口消息，以及鼠标移动、点击，键盘输入都是属于这种消息。

3. Notification:这种消息由控件产生，为的是向其父窗口(通常是对话框窗口)通知某种情况。当一个窗口内的子控件发生了一些事情，而这些是需要通知父窗口的，此刻它就上场啦。通知消息只适用于标准的窗口控件如按钮、列表框、组合框、编辑框，以及Windows公共控件如树状视图、列表视图等。

队列消息和非队列消息

Windows中有一个系统消息队列，对于每一个正在执行的Windows应用程序,系统为其建立一个“消息队列”，即应用程序队列，用来存放该程序可能创建的各种窗口的消息。

(1)队列消息(Queued Messages)

消息会先保存在消息队列中，通过消息循环从消息队列中获取消息并分发到各窗口函数去处理，如鼠标、键盘消息就属于这类消息。

(2)非队列消息(NonQueued Messages)

就是消息会直接发送到窗口函数处理，而不经过消息队列。 如： WM_ACTIVATE, WM_SETFOCUS, WM_SETCURSOR， WM_WINDOWPOSCHANGED就属于此类。

PostMessage与SendMessage的区别

PostMessage发送的消息是队列消息，它会把消息Post到消息队列中； SendMessage发送的消息是非队列消息， 被直接送到窗口过程处理，等消息被处理后才返回。

图 4 ：消息队列示意图

为证明这一过程，我们可以改动一下上面的这个例子。

1.在Win32Test.h中添加ID_BUTTON_TEST的定义

#define ID_BUTTON_TEST      1002

2.在OnButtonWhite中分别用SendMessage和PostMessage发送消息

//按下hBtWhite时的事件

void OnButtonWhite()
{
    g_bWhite = true;
    InvalidateRect(g_hWnd, NULL, FALSE);    //刷新窗口
    SendMessage(g_hWnd, WM_COMMAND, ID_BUTTON_TEST, 0);
    //PostMessage(g_hWnd, WM_COMMAND, ID_BUTTON_TEST, 0);
}

3.在消息循环中增加ID_BUTTON_TEST的判断

while (GetMessage(&msg, NULL, 0, 0))
    {
        if (LOWORD(msg.wParam) == ID_BUTTON_TEST)
        {
            OutputDebugString(L"This is a ID_BUTTON_TEST message.");    // [BreakPoint1]
        }
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

4.在窗口处理函数WndProc增加ID_BUTTON_TEST的判断

case ID_BUTTON_TEST:
    {
        OutputDebugString(L"This is a ID_BUTTON_TEST message.");        // [BreakPoint2]
    }
    break;
case ID_BUTTON_DRAW:
    OnButtonWhite();
    break;
case ID_BUTTON_SWEEP:
    OnButtonGray();
    break;

用断点调试的方式我们发现，用SendMessage发送的ID_BUTTON_TEST消息只会进入BreakPoint2，而PostMessage发送的ID_BUTTON_TEST会进入到BreakPoint1和BreakPoint2。


如果您有什么疑惑和想法，请在评论处给予反馈，您的反馈就是最好的测评师！由于本人技术和能力有限，如果本博文有错误或不足之处，敬请谅解并给出您宝贵的建议！


========================编程思想系列文章回顾========================

编程思想之消息机制

编程思想之日志记录

编程思想之异常处理

编程思想之正则表达式

编程思想之迭代器

编程思想之递归

编程思想之回调

时间： 2024-09-30 14:51:48

深入Windows内核——C++中的消息机制的相关文章

【转】深入Windows内核——C++中的消息机制

上节讲了消息的相关概念,本文将进一步聊聊C++中的消息机制. 从简单例子探析核心原理 在讲之前,我们先看一个简单例子:创建一个窗口和两个按钮,用来控制窗口的背景颜色.其效果 图1.效果图  Win32Test.h 1 #pragma once 2 3 #include <windows.h> 4 #include <atltypes.h> 5 #include <tchar.h> 6 7 //资源ID 8 #define ID_BUTTON_DRAW 1000 9 #d

Android中的消息机制

在分析Android消息机制之前.我们先来看一段代码: public class MainActivity extends Activity implements View.OnClickListener { private TextView stateText; private Button btn; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); s

浅析Android中的消息机制（转）

原博客地址:http://blog.csdn.net/liuhe688/article/details/6407225 在分析Android消息机制之前,我们先来看一段代码: 1 public class MainActivity extends Activity implements View.OnClickListener { 2 private TextView stateText; 3 private Button btn; 4 5 @Override 6 public void onC

浅析Android中的消息机制-解决：Only the original thread that created a view hierarchy can touch its views.

在分析Android消息机制之前,我们先来看一段代码: [html] view plaincopyprint? public class MainActivity extends Activity implements View.OnClickListener { private TextView stateText; private Button btn; @Override public void onCreate(Bundle savedInstanceState) { super.onC

浅析Android中的消息机制(转)

在分析Android消息机制之前,我们先来看一段代码: public class MainActivity extends Activity implements View.OnClickListener { private TextView stateText; private Button btn; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); s

再战MFC中的消息机制

时间一长就忘记MFC中的很多东西了,所以需要把这些基本的知识理一理,为能深入到MFC内部结果原理,现在需要把这些东西让度娘吐出来: 1.MFC中的消息队列情况(一个消息队列可以容纳多少消息) 原文可以在msdn中搜索"About Messages and Message Queues "找到: The system maintains a single system message queue and one thread-specific message queue for each

深入解析Android中Handler消息机制

Android提供了Handler 和 Looper 来满足线程间的通信.Handler先进先出原则.Looper类用来管理特定线程内对象之间的消息交换(MessageExchange).Handler消息机制可以说是Android系统中最重要部分之一,所以,本篇博客我们就来深入解析Android中Handler消息机制. Handler的简单使用 为什么系统不允许子线程更新UI 因为的UI控件不是线程安全的. 如果在多线程中并发访问可能会导致UI控件处于不可预期的状态,那为什么不对UI控件的访

windows内核驱动中的链表结构

windows内核驱动中的链表结构与数据结构中的链表结构在构造上有很大不同,以循环双链表为例 数据结构中的链表结构: 数据就像集装箱,可以直接放置在火车上,而节点就像每节之间的挂接装置. 内核驱动中的链表结构: 数据就像车厢,自带挂接装置(节点) 1.链表结构体不同 数据结构中的链表结构,包含有节点和数据, struct DataList{ DataType data; struct DataList* next; struct DataList* prev; }; 驱动中的链表结构,仅包含有节

Android中对消息机制(Handler)的再次解读

今天遇到一些关于在子线程中操作Handler的问题,感觉又要研究源代码了,但是关于Handler的话,我之前研究过,可以参考这篇文章:http://blog.csdn.net/jiangwei0910410003/article/details/17021809.但是这篇文章没有说的那么深入了,所以这次就更深入的解读一下. 摘要 Android中的应用程序都是通过消息驱动的,系统为每一个应用程序维护一个消息队列(MessageQueue),应用程序的主线程不断的从这个消息队列中获取消息(Loop