《Qt从零入门系列（十一）：Qt事件机制详解——从QEvent到鼠标、键盘与定时器事件》

Qt作为主流GUI开发框架，其核心交互能力，全都架在事件机制这根骨头上。你平时点的按钮、敲的文本、拖的窗口，背后无一例外，都是操作系统先产生事件，再由Qt封装好，递到应用程序手里。绝大多数场景下，信号槽足够好用，点一下、响一下，轻松搞定。可一旦要做高度自定义的交互，比如给按钮加悬停动画、全局拦截键盘快捷键、鼠标拖拽画图、精准控制定时器，信号槽就有点力不从心了。这时候，必须往下沉一层，到事件机制的地盘上动手。

本文会把Qt事件机制的完整知识体系系统梳理一遍：先从事件与信号槽的本质关系切入，再逐一拆解常见事件的处理方法、代码实现和注意事项，最后揭开事件分发器的工作原理。所有内容都配着实战案例，确保你读完既能看懂底层逻辑，又能直接把代码搬进项目里用。

一、认识Qt事件机制------事件与信号槽有什么关系

[1.1 事件与信号槽------两套机制究竟有什么关系](#1.1 事件与信号槽——两套机制究竟有什么关系)

[1.2 QEvent------Qt事件的基础类型体系](#1.2 QEvent——Qt事件的基础类型体系)

[1.3 一个事件是如何被Qt处理的](#1.3 一个事件是如何被Qt处理的)

二、鼠标事件------从进入窗口到滚轮操作

[2.1 鼠标进入与离开------捕获鼠标经过窗口的状态变化](#2.1 鼠标进入与离开——捕获鼠标经过窗口的状态变化)

[2.1.1 事件函数原型](#2.1.1 事件函数原型)

[2.1.2 从重写函数到完整实现](#2.1.2 从重写函数到完整实现)

[2.2 鼠标点击------判断按下了哪个按键](#2.2 鼠标点击——判断按下了哪个按键)

[2.2.1 函数原型与参数解析](#2.2.1 函数原型与参数解析)

[2.2.2 如何判断鼠标按键类型](#2.2.2 如何判断鼠标按键类型)

[2.2.3 鼠标点击事件的完整实现](#2.2.3 鼠标点击事件的完整实现)

[2.3 鼠标释放与双击事件](#2.3 鼠标释放与双击事件)

[2.3.1 鼠标释放事件的处理](#2.3.1 鼠标释放事件的处理)

[2.3.2 鼠标双击事件的处理](#2.3.2 鼠标双击事件的处理)

[2.3.3 鼠标释放与双击中的注意事项](#2.3.3 鼠标释放与双击中的注意事项)

[2.4 鼠标移动事件------默认行为与鼠标追踪](#2.4 鼠标移动事件——默认行为与鼠标追踪)

[2.4.1 默认鼠标移动行为与鼠标追踪](#2.4.1 默认鼠标移动行为与鼠标追踪)

[2.4.2 鼠标移动事件的实现](#2.4.2 鼠标移动事件的实现)

[2.5 鼠标滚轮事件------根据滚动距离处理操作](#2.5 鼠标滚轮事件——根据滚动距离处理操作)

[2.5.1 函数原型与delta()方法](#2.5.1 函数原型与delta()方法)

[2.5.2 通过累计滚动距离实现滚轮效果](#2.5.2 通过累计滚动距离实现滚轮效果)

三、键盘事件------从按键识别到快捷键

[3.1 键盘事件在什么条件下触发](#3.1 键盘事件在什么条件下触发)

[3.2 如何捕获并判断单个按键](#3.2 如何捕获并判断单个按键)

[3.3 组合键与快捷键的处理方式](#3.3 组合键与快捷键的处理方式)

[3.4 键盘事件与QShortcut有什么区别](#3.4 键盘事件与QShortcut有什么区别)

四、定时器事件------QTimerEvent的使用

[4.1 QTimerEvent的基本使用方式](#4.1 QTimerEvent的基本使用方式)

[4.2 定时器事件的关键函数与工作方式](#4.2 定时器事件的关键函数与工作方式)

[4.2.1 核心函数与调用方式](#4.2.1 核心函数与调用方式)

[4.2.2 定时器ID------如何区分不同定时器](#4.2.2 定时器ID——如何区分不同定时器)

[4.2.3 使用定时器实现完整倒计时功能](#4.2.3 使用定时器实现完整倒计时功能)

[4.3 QTimer与QTimerEvent------两种定时方式有什么区别](#4.3 QTimer与QTimerEvent——两种定时方式有什么区别)

五、窗口事件------窗口发生变化时会收到什么事件

[5.1 moveEvent：处理窗口移动](#5.1 moveEvent：处理窗口移动)

[5.2 resizeEvent：处理窗口大小变化](#5.2 resizeEvent：处理窗口大小变化)

六、事件分发器------Qt如何把事件交给对象

[6.1 事件分发器的基本工作原理](#6.1 事件分发器的基本工作原理)

[6.2 event()函数------统一处理事件的入口](#6.2 event()函数——统一处理事件的入口)

七、事件机制总结

结尾

一、认识Qt事件机制------事件与信号槽有什么关系

1.1 事件与信号槽------两套机制究竟有什么关系

用户不管做什么，点鼠标、敲键盘、拖窗口，都会先产生一个操作系统级别的事件。Qt拿到这些原生事件，做了第一层封装，搭出了自己的事件体系。但光有事件还不够，为了让大家写代码更省心，Qt 又在此基础上做了第二层封装，这才有了我们熟悉的信号槽。

本质关系就一句话：信号槽是事件的进一步封装，事件是信号槽的底层支撑。

拿按钮的clicked()信号来说，它本质上就是mousePressEvent和mouseReleaseEvent两个事件组合出来的产物。按下、松开，两步凑齐，信号才发得出来。

使用场景，也分两拨：

90%以上的常规交互，信号槽就够用了，代码简洁，维护也省心。
碰上Qt没提供现成信号，或者需要高度自定义的交互逻辑时，就得直接把事件机制搬出来。
事件机制给开发者留了更深的定制空间，信号槽搞不定的活儿，它能接。

1.2 QEvent------Qt事件的基础类型体系

Qt里所有事件，追根溯源，都继承自同一个基类QEvent。不同的事件类型，由各自的子类来扛，每个事件对象身上，都背着这次交互的详细情报。

下面这张表，把核心事件子类和它们对应的场景、携带的关键信息，一并列清楚：

事件子类	触发场景	携带的核心信息
QMouseEvent	鼠标按下、移动、松开	坐标位置、按下的按键、全局/局部坐标
QKeyEvent	键盘按键按下、松开	按键编码、修饰键（Ctrl/Shift 等）
QTimerEvent	定时器到点	定时器ID
QWheelEvent	鼠标滚轮滚动	滚动距离、滚动方向
QPaintEvent	窗口需要重绘	重绘区域
QMoveEvent	窗口位置移动	新旧位置坐标
QResizeEvent	窗口大小改变	新旧尺寸

每个事件子类，都带着自己专属的那份信息。你处理鼠标事件，能拿到坐标；处理键盘事件，能拿到键码；处理重绘事件，能拿到需要刷新的区域。各司其职，互不越界。

1.3 一个事件是如何被Qt处理的

Qt里处理事件，核心招数就一个：重写父类的虚事件处理函数。 这套玩法，靠的正是C++的多态机制。

流程走下来，四步：

创建自定义类，继承自Qt提供的标准控件类，比如QLabel、QWidget、QPushButton。
重写父类对应的虚事件处理函数，像enterEvent()、mousePressEvent()这些。
把 UI 设计器里拖放的标准控件，提升为自定义类的实例。
事件一触发，Qt通过多态机制，自动调用你重写的那个函数。

听起来简单，但有个坑必须盯死：重写事件函数时，函数名、参数类型、参数个数，必须跟父类一模一样，否则多态根本触发不了。 差一个字、错一个类型，编译器不报错，但你的函数就是个摆设，事件来了也不理你。

还有一点，特别容易栽：注意函数名的大小写。 Qt的事件函数，统统以小写字母开头。mousePressEvent不能写成MousePressEvent，enterEvent也不能写成EnterEvent。大写一开，多态就跟你无缘了。

二、鼠标事件------从进入窗口到滚轮操作

鼠标事件，是GUI开发里出场率最高的一类事件。鼠标的进入、离开、点击、移动、滚轮......统统归它管。

2.1 鼠标进入与离开------捕获鼠标经过窗口的状态变化

这两个事件，专门盯着鼠标光标什么时候溜进控件区域、什么时候又溜出去。悬停效果、提示信息，多半靠它们实现。

2.1.1 事件函数原型

cpp 复制代码

// 鼠标进入控件时触发
[virtual protected] void QWidget::enterEvent(QEvent *event);

// 鼠标离开控件时触发
[virtual protected] void QWidget::leaveEvent(QEvent *event);

重写的时候，记得保持函数签名一致：virtual protected不能少，参数类型也得对上。Qt5里，enterEvent的参数是QEvent *；到了Qt6，它换成了QEnterEvent *。版本不同，细节有变，写代码时留意一下手头的Qt版本。

2.1.2 从重写函数到完整实现

光看原型不过瘾，我们直接动手做一个。整个流程分三步：写自定义类、实现事件函数、把控件"提拔"成自己的类。

第一步：创建自定义Label类，继承自QLabel

头文件label.h：

cpp 复制代码

#ifndef LABEL_H
#define LABEL_H
#include <QLabel>

class Label : public QLabel
{
    Q_OBJECT
public:
    Label(QWidget *parent = nullptr);

protected:
    void enterEvent(QEvent *event) override;
    void leaveEvent(QEvent *event) override;
};

#endif // LABEL_H

第二步：在源文件里重写事件函数

label.cpp：

cpp 复制代码

#include "label.h"
#include <QDebug>

Label::Label(QWidget *parent) : QLabel(parent)
{
}

void Label::enterEvent(QEvent *event)
{
    (void)event; // 消掉"未使用参数"的警告
    qDebug() << "鼠标进入Label区域";
}

void Label::leaveEvent(QEvent *event)
{
    (void)event;
    qDebug() << "鼠标离开Label区域";
}

这里有个小细节：(void)event;这行不是多余的。参数没用上，编译器会唠叨，加这一句，相当于告诉它："我知道有这么个东西，故意不用，别念了。"

第三步：把UI里的标准控件，提升成自定义类

在UI设计器里拖一个QLabel出来。
右键点它，选"提升为"。
弹窗里，基类名称填QLabel，提升的类名称填Label，头文件填label.h。
点"添加"，再点"提升"。

搞定。此时界面上那个QLabel，骨子里已经换成了我们自定义的Label类。运行程序，鼠标一进一出，控制台就会乖乖打印出对应的提示。一个最简单的自定义事件处理，就这么跑通了。

2.2 鼠标点击------判断按下了哪个按键

这个事件专门抓鼠标按键的"按下"操作。点哪儿了、按的是哪个键，它都给你记着。

2.2.1 函数原型与参数解析

cpp 复制代码

[virtual protected] void QWidget::mousePressEvent(QMouseEvent *event);

参数QMouseEvent* event身上，背着这次点击的全部信息：

event->x() / event->y()：点击位置相对于控件左上角的局部坐标。
event->globalX() / event->globalY()：点击位置相对于屏幕左上角的全局坐标。
event->button()：返回按下的鼠标按键，类型是Qt::MouseButton枚举。

局部坐标和全局坐标，听着差不多，用起来天差地别。控件内部处理，用局部；要跟屏幕或其他窗口打交道，就得切到全局。

2.2.2 如何判断鼠标按键类型

Qt::MouseButton枚举把支持的按键全列了出来：

cpp 复制代码

Qt::LeftButton    // 左键 0x00000001
Qt::RightButton   // 右键 0x00000002
Qt::MiddleButton  // 中键（滚轮）0x00000004
Qt::BackButton    // 侧键后退 0x00000008
Qt::ForwardButton // 侧键前进 0x00000010

注意到了吗？每个按键对应的值，都是2的幂，1、2、4、8、16。这不是巧合。用2的幂做值，就能靠按位与&来同时判断多个按键的组合，一个整数装下所有状态，干净利落。

2.2.3 鼠标点击事件的完整实现

在自定义Label类里，把鼠标按下事件补上。

先在label.h里加声明：

cpp 复制代码

protected:
    void mousePressEvent(QMouseEvent *event) override;

然后在label.cpp里实现：

cpp 复制代码

#include <QMouseEvent>

void Label::mousePressEvent(QMouseEvent *event)
{
    // 判断按下的按键
    if (event->button() == Qt::LeftButton) {
        qDebug() << "按下鼠标左键";
    } else if (event->button() == Qt::RightButton) {
        qDebug() << "按下鼠标右键";
    } else if (event->button() == Qt::MiddleButton) {
        qDebug() << "按下鼠标中键";
    }

    // 输出坐标信息
    qDebug() << "局部坐标：" << event->x() << "," << event->y();
    qDebug() << "全局坐标：" << event->globalX() << "," << event->globalY();
}

这段逻辑很直白：先看event->button()返回的是哪个键，分门别类打日志；再把这次点击的局部坐标和全局坐标都亮出来。

有一个细节值得留意：event->button()在鼠标按下事件里，返回的是当前这一次触发的那个按键。也就是说，如果你同时按下了左右键，每次触发只会返回其中一个。而如果你想判断"此刻有哪些键被按着"，那得用event->buttons()，注意末尾多了一个s，返回的是一组按键的位掩码。一个是单数，一个是复数，别搞混了。

2.3 鼠标释放与双击事件

2.3.1 鼠标释放事件的处理

按键松手的那一刻，就轮到它登场了。

cpp 复制代码

// 函数原型
[virtual protected] void QWidget::mouseReleaseEvent(QMouseEvent *event);

// 实现代码
void Label::mouseReleaseEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        qDebug() << "释放鼠标左键";
    } else if (event->button() == Qt::RightButton) {
        qDebug() << "释放鼠标右键";
    }
}

跟按下事件一样，event->button()告诉你松手的是哪个键。按下、释放，成对出现，一次完整的点击才算画上句号。

2.3.2 鼠标双击事件的处理

双击有自己专属的事件处理函数，不用你自己去数点击次数。

cpp 复制代码

// 函数原型
[virtual protected] void QWidget::mouseDoubleClickEvent(QMouseEvent *event);

// 实现代码
void Label::mouseDoubleClickEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton) {
        qDebug() << "双击鼠标左键";
    }
}

2.3.3 鼠标释放与双击中的注意事项

这里有个很容易踩坑的地方：双击不是独立动作。 系统会先给你来两轮单击的按下和释放，然后才轮到双击事件登场。也就是说，一次双击，背后其实藏着四次事件：按下、释放、按下、释放，最后才补一个双击。

如果你同时实现了单击和双击逻辑，就得留神冲突了。用户双击的时候，单击逻辑也会被触发两次。想区分清楚，常见的做法是：用定时器延迟判断。 单击之后不急着执行，先等一小会儿，如果在延迟期间来了第二次点击，那就当双击处理；如果没来，才把它当成单击。多等那么一下，逻辑就分清了。

2.4 鼠标移动事件------默认行为与鼠标追踪

这个事件负责实时汇报鼠标的移动位置。拖拽、绘制这类需要"跟着鼠标走"的功能，全靠它撑着。

2.4.1 默认鼠标移动行为与鼠标追踪

Qt默认并不追踪鼠标移动。鼠标在控件上滑来滑去，只要没按下按键，mouseMoveEvent就一声不吭。只有按键处于按下状态时，它才肯干活。如果你想让鼠标不按键也能被追踪，比如做悬停提示、画板预览，那就得手动打开开关。在控件的构造函数里补上这么一句：

cpp 复制代码

this->setMouseTracking(true);

加上它，鼠标的每一次挪动都会触发事件，实时感立刻拉满。不少人第一次用mouseMoveEvent 时会纳闷：怎么不动？八成就是忘了打开这个开关。

2.4.2 鼠标移动事件的实现

先在widget.h里声明：

cpp 复制代码

protected:
    void mouseMoveEvent(QMouseEvent *event) override;

再到widget.cpp里实现，构造函数中记得把鼠标追踪打开：

cpp 复制代码

Widget::Widget(QWidget *parent) : QWidget(parent), ui(new Ui::Widget)
{
    ui->setupUi(this);
    this->setMouseTracking(true); // 开启鼠标追踪
}

void Widget::mouseMoveEvent(QMouseEvent *event)
{
    qDebug() << "鼠标移动到：" << event->x() << "," << event->y();
}

有一件事得留心：鼠标移动事件的触发频率非常高，鼠标轻轻一划，回调可能就被拉起来几十上百次。要是处理函数里塞了复杂逻辑，程序很容易被拖卡。所以，能精简就精简，能缓存就缓存，别让高频事件变成性能黑洞。

2.5 鼠标滚轮事件------根据滚动距离处理操作

鼠标滚轮那点动静，全靠这个事件来抓。缩放、滚动列表，都指望它来感知。

2.5.1 函数原型与delta()方法

cpp 复制代码

[virtual protected] void QWidget::wheelEvent(QWheelEvent *event);

event->delta()返回滚轮滚动的距离，单位是1/8度。

向上滚：返回正值，通常为120。
向下滚：返回负值，通常为-120。

2.5.2 通过累计滚动距离实现滚轮效果

先在widget.h里备一个计数器：

cpp 复制代码

private:
    int totalDelta = 0;

protected:
    void wheelEvent(QWheelEvent *event) override;

再到widget.cpp里实现：

cpp 复制代码

#include <QWheelEvent>

void Widget::wheelEvent(QWheelEvent *event)
{
    totalDelta += event->delta();
    qDebug() << "本次滚动距离：" << event->delta();
    qDebug() << "累计滚动距离：" << totalDelta;
}

每滚一下，delta()就把这次的滚动量报出来，顺手累加到totalDelta上。一次一记，积少成多，滚了多少，心里有数。

顺带提一句：在Qt6里，delta()已经退休，换成了angleDelta()。核心思路没变，只是API换了个名字。如果项目跨版本，这点得留个心。

三、键盘事件------从按键识别到快捷键

键盘事件，专门收拾用户的键盘输入。单个按键也好，Ctrl、Shift这种组合键也罢，都归它管。

3.1 键盘事件在什么条件下触发

键盘事件有个前提：控件或窗口必须处于激活状态。 焦点在你这儿，按键才轮得到你接。焦点要是跑到别的控件或者别的程序那儿去了，那这些键盘输入就跟你没关系了，全被人家截走。

3.2 如何捕获并判断单个按键

cpp 复制代码

// 函数原型
[virtual protected] void QWidget::keyPressEvent(QKeyEvent *event);
[virtual protected] void QWidget::keyReleaseEvent(QKeyEvent *event);

event->key()返回按下的按键编码，对应的是Qt::Key_*这一套枚举。

看实现代码：

cpp 复制代码

#include <QKeyEvent>

void Widget::keyPressEvent(QKeyEvent *event)
{
    qDebug() << "按下按键编码：" << event->key();

    // 判断具体按键
    if (event->key() == Qt::Key_A) {
        qDebug() << "按下了A键";
    } else if (event->key() == Qt::Key_Escape) {
        qDebug() << "按下了ESC键";
        this->close(); // 按下ESC关闭窗口
    }
}

逻辑不复杂：先把按键编码打出来，再拿event->key()去跟具体的键比对。Qt::Key_A是A键，Qt::Key_Escape是ESC键，一比对就知道用户按了哪个。上面这段，ESC一按，窗口直接关掉，干脆利落。

3.3 组合键与快捷键的处理方式

单个键好办，可一旦遇上Ctrl、Shift、Alt这些修饰键，就得换个姿势了。光靠event->key()只能知道用户敲了哪个主键，想知道他有没有同时按着Ctrl，还得看另一个方法：event->modifiers()。

它返回的是修饰键的状态，对应Qt::KeyboardModifier枚举：

Qt::ControlModifier：Ctrl 键
Qt::ShiftModifier：Shift 键
Qt::AltModifier：Alt 键

看代码，处理Ctrl + A：

cpp 复制代码

void Widget::keyPressEvent(QKeyEvent *event)
{
    if (event->key() == Qt::Key_A && event->modifiers() == Qt::ControlModifier) {
        qDebug() << "按下了Ctrl+A组合键";
        // 实现全选逻辑
    }
}

这里两个条件必须同时成立：主键是A，修饰键是Ctrl。缺一个，组合键就不成立。两个条件一卡，Ctrl+A就被精准捕获了，后面接上全选逻辑，快捷键就算落地了。

3.4 键盘事件与QShortcut有什么区别

快捷键这东西，不是非得用键盘事件硬啃。

简单的快捷键，直接上QShortcut类，走信号槽那套，代码更短，写起来也清爽。点一下、连一下，逻辑就通了。

可要是碰上复杂的键盘玩法，连续按键、长按检测、组合键嵌套，那还是得回到键盘事件上来。它给的自由度更高，想怎么处理就怎么处理，不受信号槽的条条框框限制。

所以选哪个，看需求：图省事，用QShortcut；要深度定制，上键盘事件。

四、定时器事件------QTimerEvent的使用

定时器这东西，就是用来周期性干活的------做动画、搞倒计时、定时刷新，都离不开它。Qt给了两套方案：一套是高层接口QTimer，一套是底层事件QTimerEvent。

4.1 QTimerEvent的基本使用方式

QTimerEvent是Qt定时器的底层实现。不管上层怎么封装，所有定时器最终都会落到这个事件上。

4.2 定时器事件的关键函数与工作方式

4.2.1 核心函数与调用方式

cpp 复制代码

int startTimer(int interval);          // 开启定时器，参数是间隔时间（毫秒），返回唯一的定时器 ID
void killTimer(int id);                // 根据定时器 ID 停止定时器
void timerEvent(QTimerEvent *event);   // 定时器事件处理函数，所有定时器触发时都会调用它

三个函数，各管一摊：startTimer负责生，killTimer负责杀，timerEvent负责干活。一开一关一处理，闭环就成了。

4.2.2 定时器ID------如何区分不同定时器

每次调用startTimer，它都会还你一个独一无二的ID。这个ID，就是用来区分不同定时器的。它有点像Linux里的文件描述符，都是个整数，都是身份标识，你拿着它，就知道自己在跟谁打交道。

程序里要是有多个定时器，那就必须在timerEvent里靠这个ID来判断：这次到底是哪个定时器响了？认错了ID，逻辑就串了。一个ID对一摊事，分清楚，才不会乱。

4.2.3 使用定时器实现完整倒计时功能

代码不复杂，但把定时器的生、用、杀串成了一条完整的线。先看头文件：

cpp 复制代码

// widget.h
private:
    Ui::Widget *ui;
    int timerId; // 保存定时器ID

protected:
    void timerEvent(QTimerEvent *event) override;

再看实现：

cpp 复制代码

// widget.cpp
Widget::Widget(QWidget *parent) : QWidget(parent), ui(new Ui::Widget)
{
    ui->setupUi(this);

    // LCD 初始值设为 10
    ui->lcdNumber->display(10);

    // 开启一个 1 秒间隔的定时器
    timerId = this->startTimer(1000);
}

Widget::~Widget()
{
    delete ui;
}

void Widget::timerEvent(QTimerEvent *event)
{
    // 先认门：不是我们的定时器，直接忽略
    if (event->timerId() != this->timerId) {
        return;
    }

    // 看看 LCD 上现在显示多少
    int value = ui->lcdNumber->intValue();

    if (value <= 0) {
        // 倒计时归零，停掉定时器，收工
        this->killTimer(this->timerId);
        qDebug() << "倒计时结束";
        return;
    }

    // 数字减一，刷新显示
    value--;
    ui->lcdNumber->display(value);
}

这段代码里，几个动作配合得很干净：构造函数里开定时器，timerEvent里判断ID、检查数值、递减刷新，归零之后果断killTimer收手。没有多余的纠缠，倒计时就这么一秒一秒走完了。

4.3 QTimer与QTimerEvent------两种定时方式有什么区别

QTimer是高层接口，走的是信号槽那一套。一个定时器对应一个对象，代码读起来清爽，维护也省心。实际开发里，它基本就是首选。
QTimerEvent则蹲在底层，玩的是事件机制。定时器ID得自己亲手管，多个定时器还挤在同一个处理函数里，代码相对麻烦。但麻烦也有麻烦的回报，它更灵活，想怎么折腾都行。

五、窗口事件------窗口发生变化时会收到什么事件

窗口的位置挪了、大小变了，这些动静，全归窗口事件来管。想做自适应布局、想盯住窗口状态的一举一动，背后都得靠它来捕获。

5.1 moveEvent：处理窗口移动

窗口被拖动、位置发生变化的那一刻，这个函数就会被触发。

cpp 复制代码

// 函数原型
[virtual protected] void QWidget::moveEvent(QMoveEvent *event);

实现代码：

cpp 复制代码

#include <QMoveEvent>

void Widget::moveEvent(QMoveEvent *event)
{
    qDebug() << "窗口旧位置：" << event->oldPos();
    qDebug() << "窗口新位置：" << event->pos();
}

event->oldPos()拿到的是移动前的坐标，event->pos()则是移动后的新坐标。一旧一新，窗口从哪儿挪到哪儿，看得清清楚楚。

5.2 resizeEvent：处理窗口大小变化

窗口被拖大、拖小，尺寸一变，这个事件立马触发。

cpp 复制代码

// 函数原型
[virtual protected] void QWidget::resizeEvent(QResizeEvent *event);

实现代码：

cpp 复制代码

#include <QResizeEvent>

void Widget::resizeEvent(QResizeEvent *event)
{
    qDebug() << "窗口旧尺寸：" << event->oldSize();
    qDebug() << "窗口新尺寸：" << event->size();
    qDebug() << "新宽度：" << event->size().width();
    qDebug() << "新高度：" << event->size().height();
}

event->oldSize()记下改变前的尺寸，event->size()给出改变后的新尺寸。想单独拿宽度和高度的，再调.width()和.height()就行。一旧一新，窗口是怎么被拉长、压扁的，全在这几行里了。

六、事件分发器------Qt如何把事件交给对象

6.1 事件分发器的基本工作原理

Qt里所有事件，不用管从哪来，第一站都是QObject::event()函数。它就是事件分发的总入口，所有事件都得先到这儿报到。但event()本身不干活。它不直接处理事件，而是先看一眼事件的类型，也就是event->type()返回的那个值，然后照着类型，把事件转手交给对应的具体处理函数。鼠标事件给mousePressEvent()，键盘事件给keyPressEvent()，各回各家，各找各妈。

所以，event()的角色更像一个调度台：来什么件，分什么窗口。它只负责判断和转发，真正的处理逻辑，还是落在那些具体的xxxEvent()函数身上。

6.2 event()函数------统一处理事件的入口

event()是事件分发的总入口，平时它只是按部就班地判断类型、转手分发。但你可以把这个入口重写掉，在半道上设一道关卡，把经过的事件先拦下来审一遍，实现全局的事件处理或过滤。

cpp 复制代码

bool Widget::event(QEvent *event)
{
    // 拦截所有鼠标按下事件
    if (event->type() == QEvent::MouseButtonPress) {
        qDebug() << "拦截到鼠标按下事件";
        // 返回 true，表示事件已处理，不再往下分发
        return true;
    }

    // 其他事件，交给父类继续处理
    return QWidget::event(event);
}

这里的关键在于返回值：返回true，就等于告诉Qt"这事儿我处理了"，事件到此为止，不再往下走；返回false或者调用父类的event()，事件才会继续分发。

重写event()相当于拿了一张全局拦截的通行证。所有事件在送往具体处理函数之前，都得先过你这道关。想做全局快捷键、统一日志、特殊事件屏蔽，这里是最合适的下手点。

七、事件机制总结

本文把Qt事件机制的完整知识体系系统梳理了一遍，核心要点整理如下：

**本质关系：**信号槽是事件的上层封装，事件是信号槽的底层支撑。常规场景用信号槽，自定义场景用事件。

**核心处理方式：**继承标准控件类，重写对应的虚事件处理函数，再把 UI 控件提升为自定义类的实例。

鼠标事件：

进入离开：enterEvent() / leaveEvent()
点击释放：mousePressEvent() / mouseReleaseEvent()，能拿到局部/全局坐标和按键类型
移动事件：默认不追踪，想追踪得手动调 setMouseTracking(true)
滚轮事件：wheelEvent()，用 delta() 拿滚动距离
键盘事件：keyPressEvent() / keyReleaseEvent()，靠 key() 判断单个按键，靠 modifiers() 判断组合键。

定时器事件：

高层接口 QTimer（推荐），底层事件 QTimerEvent
QTimerEvent 得自己管定时器 ID，在 timerEvent() 里区分不同定时器

**窗口事件：**moveEvent() 捕获位置变化，resizeEvent() 捕获大小变化。

**事件分发器：**所有事件都要经过 event() 函数分发。可以重写它来拦截事件，但用的时候得悠着点。

实际开发中，遵循一条原则就好：优先用信号槽，必要时上事件。 在保证代码简洁的同时，把想要的效果做出来。掌握事件机制，是深入Qt开发的必经之路，它让你真正理解GUI程序的交互本质，也让你有能力实现更灵活、更强大的自定义控件和交互效果。

结尾

到这里，Qt事件机制的核心内容就全部讲完了。从鼠标、键盘到定时器、窗口，再到事件分发器，这一路走下来，你会发现，GUI程序的每一次"回应"，背后都是事件在驱动。信号槽让开发变简单，事件机制则让定制变自由。真正理解事件，才算摸到了Qt交互的底层脉搏。

接下来，把这些代码跑一跑、改一改，试着给自己的控件加上悬停动画、全局快捷键或者拖拽绘制。你会发现，事件机制远比想象中强大。很多看似复杂的交互效果，拆开看，不过是几个事件函数的组合而已。

感谢阅读。如果本文对你有帮助，别忘了点赞、收藏、关注三连支持。你的每一次反馈，都是我继续硬核输出的最大动力。我们下篇见。