Qt 实战：信号与槽+事件系统

一、Qt6 信号与槽核心知识点

1. 什么是信号与槽

信号与槽是 Qt 独有的对象间通信机制，替代传统回调函数，可读性、解耦性更强：

• 信号 (signal)：当对象状态 / 动作改变时主动发送的通知。比如按钮点击clicked()、输入框文本变化、自定义登录成功通知。 特点：只声明不实现、无返回值、支持函数重载、通过emit触发。
• 槽 (slot)：接收信号后执行业务逻辑的函数。普通成员函数、lambda 表达式都可以作为槽。
• connect 函数：桥梁，绑定「发送对象 - 信号」和「接收对象 - 槽函数」，信号触发自动执行槽逻辑。

2. Q_OBJECT 宏

        只要类中使用 signals、slots、自定义信号，类定义第一行必须添加 Q_OBJECT。 Qt 会通过 MOC 工具生成元对象代码，缺失会出现 undefined reference 链接报错。

3. 重载信号的两种方式

        当一个类存在同名不同参数的信号（本项目 LoginWidget 有两个loginOk信号），编译器无法自动匹配，必须手动指定重载版本：

方式 1：QOverload<参数类型>::of(&类名::信号)

QOverload<>::of(&LoginWidget::loginOk)

方式 2：定义信号函数指针

void (QComboBox::*sig1)(const QString &) = &QComboBox::currentTextChanged;

4. 自定义信号编写规范

1. 头文件中 signals: 关键字下声明，不能加 public/private
2. 仅写函数声明，不需要 cpp 中实现函数体
3. 发送信号使用关键字 emit 信号名(参数);
4. 支持重载，可定义无参、带参多个同名信号

5. Qt 五种 connect 写法

写法	示例	适用场景	推荐度
Qt4 SIGNAL/SLOT 宏	connect(btn,SIGNAL(clicked()),this,SLOT(func()))	老旧项目维护，无编译检查，写错运行时报错	❌ 不推荐
Qt5 成员函数指针	connect(btn,&QPushButton::clicked,this,&Widget::btn1Handler)	无重载信号，编译期语法校验	⭐⭐⭐⭐⭐
Lambda 作为槽	connect(btn,&QPushButton::clicked,[=]{})	简单一次性逻辑、需要捕获局部变量	⭐⭐⭐⭐⭐
QOverload 处理重载信号	QOverload<QString>::of(&LoginWidget::loginOk)	信号存在重载，需要精准匹配版本	⭐⭐⭐⭐
自定义信号函数指针	void (QComboBox::*sig)(QString)=&QComboBox::currentTextChanged	重载信号，兼容老编译器	⭐⭐⭐

二、登录跳转主界面完整实现

1. 项目需求

1. 基于 Qt6.5 + CMake 搭建工程
2. 程序启动展示登录界面，校验账号密码
3. 非法输入弹出QMessageBox警告
4. 登录成功自动切换至主窗口
5. 主窗口演示全部 5 种信号槽写法，包含按钮点击计数、下拉框修改标题功能

2. 文件结构说明

3. 代码分步解析

（1）登录模块 LoginWidget：自定义重载信号 + 账号密码校验

模块设计思路

1. 使用 Qt Designer 生成 UI，自动生成on_控件名_clicked内置槽函数
2. 自定义重载信号：无参loginOk()、带用户名参数loginOk(QString)，用于向外通知登录成功
3. 登录按钮点击槽内做两层校验：先判断输入框非空，再核对固定账号密码
4. 校验失败通过QMessageBox弹出警告弹窗；校验成功使用emit发送自定义信号，页面跳转逻辑交给main.cpp处理，降低耦合

头文件 loginwidget.h

#ifndef LOGINWIDGET_H
#define LOGINWIDGET_H
// 基础窗口父类头文件
#include <QWidget>
// ui文件自动生成的命名空间，存放界面控件对象
namespace Ui {
class LoginWidget;
}
// 登录窗口类，继承QWidget基础窗口
class LoginWidget : public QWidget
{
    // 核心宏：使用信号、槽、自定义信号必须添加，MOC工具生成元对象代码
    Q_OBJECT
public:
    // 构造函数，parent为父窗口指针，默认空
    explicit LoginWidget(QWidget *parent = nullptr);
    // 析构函数，释放ui界面堆内存
    ~LoginWidget();
// 自动/自定义槽函数存放区域
private slots:
    // ui设计师拖拽按钮命名loginBtn，Qt自动生成槽函数on_loginBtn_clicked
    void on_loginBtn_clicked();
// 自定义信号区域：无访问权限修饰符，只声明、不实现
signals:
    // 重载信号1：无参登录成功信号
    void loginOk();
    // 重载信号2：携带登录用户名参数，可向外传递数据
    void loginOk(const QString &name);
private:
    // ui界面指针，管理所有输入框、按钮等控件
    Ui::LoginWidget *ui;
};
#endif // LOGINWIDGET_H

实现文件 loginwidget.cpp

#include "loginwidget.h"
// ui编译后生成的头文件，包含所有界面控件定义
#include "ui_loginwidget.h"
// 弹窗提示框类
#include <QMessageBox>
// 构造函数实现
LoginWidget::LoginWidget(QWidget *parent)
    : QWidget(parent),
      // 实例化ui界面对象，分配堆内存
      ui(new Ui::LoginWidget)
{
    // 将ui控件挂载到当前LoginWidget窗口上，渲染界面
    ui->setupUi(this);
}
// 析构函数：释放ui堆内存，防止内存泄漏
LoginWidget::~LoginWidget()
{
    delete ui;
}
// 登录按钮点击触发的槽函数
void LoginWidget::on_loginBtn_clicked()
{
    // 第一层校验：账号输入框 或 密码输入框为空
    if (ui->nameEdit->text().isEmpty() || ui->pwdEdit->text().isEmpty())
    {
        // 弹出警告弹窗：父窗口、弹窗标题、提示文本
        QMessageBox::warning(this, "提示", "账户或口令为空!");
        // 终止函数，不再执行后续账号密码校验逻辑
        return;
    }
    // 第二层校验：固定账号admin、密码admin123匹配
    if (ui->nameEdit->text() == "admin" && ui->pwdEdit->text() == "admin123")
    {
        // emit关键字：发送自定义信号1 无参版本
        emit loginOk();
        // emit关键字：发送自定义信号2 携带用户名参数版本
        emit loginOk("admin");
    }
    else
    {
        // 账号密码不匹配，弹出失败警告
        QMessageBox::warning(this, "登录失败", "账户或口令不正确!");
    }
}

        登录窗口只负责采集输入、校验规则、发送通知信号，页面切换、窗口显示隐藏的逻辑完全剥离到main.cpp，后续如果更换主界面、修改跳转逻辑，不需要改动登录窗口代码。

---

（2）主窗口 Widget：Qt 5 种 connect 信号槽写法

模块设计思路

1. 独立窗口，和登录业务解耦，专门用于对比展示 Qt 全部信号槽绑定方式
2. 定义私有成员变量count_click_num记录按钮点击次数
3. 实现自定义成员槽函数btn1Handler，配合按钮点击修改标签文字
4. 依次演示：Qt4 宏写法、Qt5 成员函数指针、Lambda 槽、QOverload 处理重载信号、函数指针处理重载信号
5. 下拉框绑定信号，选择城市实时修改窗口标题，直观展示带参数信号传递

头文件 widget.h

#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
// Qt命名空间宏，限定ui命名空间作用域
QT_BEGIN_NAMESPACE
namespace Ui {
// ui自动生成的界面类
class Widget;
}
QT_END_NAMESPACE
// 主业务窗口
class Widget : public QWidget
{
    // 使用信号槽必备元对象宏
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
// 自定义槽函数存放处
private slots:
    // 自定义成员槽函数，响应按钮点击事件
    void btn1Handler();
private:
    // ui界面对象指针
    Ui::Widget *ui;
    // 记录按钮点击总次数，私有成员变量
    int count_click_num;
};
#endif // WIDGET_H

实现文件 widget.cpp

#include "widget.h"
#include "ui_widget.h"
Widget::Widget(QWidget *parent)
    : QWidget(parent),
      // 创建ui界面实例
      ui(new Ui::Widget)
{
    // 加载渲染ui界面控件
    ui->setupUi(this);
    // 初始化点击计数为0
    count_click_num = 0;
    // 窗口内标签初始文字
    ui->label->setText("不要点我哟!");
    // ===================== 方式1：Qt4 SIGNAL/SLOT宏写法（不推荐） =====================
    // 缺点：纯字符串匹配，无编译期语法检查，函数名写错运行时才失效，无报错
    // connect(ui->btn1,SIGNAL(clicked()),this, SLOT(btn1Handler()));
    // ===================== 方式2：Qt5 类成员函数指针（无重载信号首选，推荐） =====================
    // 编译期校验函数名、参数，类型安全，适合无重载的标准控件信号
    // 参数：发送对象、信号地址、接收对象、槽函数地址
    connect(ui->btn1, &QPushButton::clicked,
            this, &Widget::btn1Handler);
    // ===================== 方式3：Lambda表达式作为槽函数（一次性临时逻辑首选） =====================
    // 优势：无需单独定义槽函数，可捕获窗口成员变量，适合简单单次回调逻辑
    // [=] 值捕获，当前类所有成员、局部变量都可访问
    connect(ui->btn1, &QPushButton::clicked, [=](){
        // 每次点击计数自增
        count_click_num++;
    });
    // ===================== 方式4：QOverload模板类处理重载信号 =====================
    // 适用场景：同一个类存在多个同名、不同参数的重载信号，编译器无法自动识别
    // auto signal1 = QOverload<const QString &>::of(&QComboBox::currentTextChanged);
    // connect(ui->cityBox, signal1,[=](const QString &city){
    //     setWindowTitle(city); // 将选中城市设置为窗口标题
    // });
    // ===================== 方式5：手动定义信号函数指针处理重载信号 =====================
    // 原理：显式声明对应参数格式的信号指针，强制编译器匹配指定重载版本
    // 格式：返回值 (类名::*指针名)(参数列表) = &类名::重载信号;
    void (QComboBox::*sig1)(const QString &) = &QComboBox::currentTextChanged;
    // 绑定下拉框选中变更信号，lambda接收选中的城市名称
    connect(ui->cityBox, sig1, [=](const QString & cityName){
       setWindowTitle(cityName);
    });
}
// 自定义成员槽函数，响应按钮点击事件
void Widget::btn1Handler()
{
    // 从未点击时的提示文字
    if(count_click_num == 0)
        ui->label->setText("点我做什么?");
    // 点击次数大于等于5次，展示点击总数
    if(count_click_num >= 5)
    {
        // QString::arg()占位符格式化字符串，%1填充count_click_num数值
        ui->label->setText(QString("你说呀，都已点了%1次").arg(count_click_num));
    }
}
// 析构释放ui内存
Widget::~Widget()
{
    delete ui;
}

        5 种connect覆盖 Qt 所有信号槽绑定场景：简单无重载信号用成员指针、临时逻辑用 Lambda、同名重载信号用QOverload/ 函数指针；同时演示带参信号传递，直观理解信号可以携带数据传给槽函数。

---

（3）main.cpp：程序入口 + 跨窗口信号通信核心

模块设计思路

1. main是 Qt 程序唯一入口，创建应用程序对象、所有窗口实例
2. 不直接调用登录窗口内部控件、不直接操作登录窗口关闭逻辑
3. 通过绑定登录窗口的自定义loginOk信号，在 lambda 中统一控制页面切换
4. 使用QOverload<>::of匹配无参版本重载信号，解决信号重载编译歧义
5. 执行流程：创建登录窗口→绑定登录成功信号→显示登录窗口→开启 Qt 事件循环

main.cpp 完整代码

// 引入登录窗口头文件
#include "loginwidget.h"
// 引入主业务窗口头文件
#include "widget.h"
// Qt应用程序基础类，管理消息循环
#include <QApplication>
// QObject是信号槽的顶层父类，connect静态函数来源
#include <QObject>
int main(int argc, char *argv[])
{
    // 创建Qt应用程序实例，接收命令行参数
    QApplication a(argc, argv);
    // 1. 创建登录窗口对象
    LoginWidget w;
    // 2. 创建主窗口对象（创建时默认隐藏，不调用show()）
    Widget mainWindow;
    // 绑定登录窗口的【无参loginOk重载信号】
    // QOverload<> 指定匹配无参数版本的loginOk信号，消除重载信号编译歧义
    QObject::connect(
        &w,                        // 信号发送者：登录窗口对象地址
        QOverload<>::of(&LoginWidget::loginOk), // 指定要绑定的无参重载信号
        [&](){                     // 槽函数：lambda表达式，引用捕获所有局部变量
            // 修改主窗口标题为会员标识
            mainWindow.setWindowTitle("admin会员");
            // 关闭登录窗口
            w.close();
            // 展示主业务窗口
            mainWindow.show();
        }
    );
    // 程序启动，先展示登录窗口
    w.show();
    // 启动Qt事件循环，阻塞等待窗口操作、信号触发，程序不退出
    return a.exec();
}

        跨窗口通信最优解：子窗口自定义信号，主入口统一接收处理页面逻辑。登录窗口和主窗口互相独立，没有任何头文件交叉包含，低耦合易维护；如果后续新增游客登录、多账号登录，只需要扩展信号参数、修改 main 里的 lambda 跳转逻辑，无需修改登录窗口源码。

4. 程序运行效果

1. 程序启动：仅弹出登录窗口，主窗口隐藏

2. 账号 / 密码输入框留空点击登录：弹窗警告「账户或口令为空！」

3. 输入错误账号密码：弹窗「账户或口令不正确！」

4. 输入 admin/admin123 登录：登录窗口关闭，弹出主窗口，窗口标题变为admin会员

5. 主窗口按钮点击：标签文字随点击次数动态变化，点击 5 次以上展示计数

6. 下拉框选择城市：窗口标题实时同步为选中城市名称

三、核心知识点总结

        信号与槽是 Qt 框架独有的对象间通信核心机制，替代传统回调函数实现低耦合交互，依靠connect函数建立信号发送者与槽函数接收者的绑定关系，自定义信号则需要通过emit关键字主动触发发送，以此完成窗口、控件之间的数据与事件传递。只要类内部声明、使用自定义信号、槽函数，都必须在类定义首行添加Q_OBJECT宏，该宏会触发 Qt 的 MOC 元对象编译工具生成底层通信代码，一旦遗漏会直接出现链接报错，导致程序编译失败。

        当类中存在同名但参数不同的重载信号时，编译器无法自动区分匹配目标，必须借助QOverload模板或者手动定义信号函数指针两种方式，显式指定要绑定的信号版本，消除编译歧义。在多窗口业务交互场景中，优先采用自定义信号完成通信解耦，不要让窗口互相包含头文件、直接调用对方 UI 控件，否则代码耦合度极高，后期迭代、修改页面逻辑时极易引发连锁 bug。

        Qt 提供五种connect绑定写法，不同场景有明确选型标准：无参数、不存在重载的标准控件信号，优先选用类成员函数指针写法，具备编译期语法校验，类型安全；仅需单次执行的简易临时逻辑，使用 Lambda 表达式充当槽函数，无需额外定义槽成员，开发效率更高；遇到重载信号时统一使用QOverload模板匹配对应版本。合理搭配不同绑定方式，搭配自定义信号实现跨窗口页面跳转、数据传递，是 Qt 界面开发规范且易维护的标准开发思路。

四、Qt6 事件系统核心知识点

1. 什么是 Qt 事件

        Qt 事件是界面交互的底层驱动机制，鼠标点击、键盘输入、窗口关闭、系统刷新都会生成对应的QEvent事件对象，由a.exec()启动的事件循环统一调度分发。 完整事件分发链路： 自定义MyApplication::notify()（全局第一层拦截）→ QWidget::event()（窗口统一分发第二层）→ keyPressEvent/closeEvent等细分专用事件函数（第三层）。 事件存在两种处理状态：

• event->accept()：当前对象消费事件，停止向上冒泡传递
• event->ignore()：当前对象不处理，事件向上传递给父控件继续处理

2. 三层事件拦截重写机制

        全局拦截 notify () 继承QApplication并重写虚函数notify(QObject *receiver, QEvent *e)，可以捕获当前程序中所有控件、所有类型的事件，适合做全局日志打印、全局操作拦截。最终必须调用父类QApplication::notify完成原生事件分发，否则界面交互失效。

        窗口统一分发 event () event(QEvent *e)是当前窗口的总事件入口，当前窗口及其子控件产生的所有事件都会先进入该函数。可以通过e->type()判断事件类型，手动转发给其他控件，也可以直接拦截阻断事件，灵活控制事件路由。

        细分专项事件函数（日常开发首选） Qt 将高频事件拆分独立虚函数，无需手动判断事件类型，逻辑更简洁。本项目实现两类典型事件：

• keyPressEvent(QKeyEvent *kevent)：处理键盘按下事件
• closeEvent(QCloseEvent *event)：窗口关闭触发事件，可增加二次确认弹窗

3. 事件阻断与转发规则

        在event()中直接return true，不调用父类方法：事件被拦截，不再向下分发到专项函数

        调用QWidget::event(e)/ 父类专项事件函数：执行 Qt 默认原生处理逻辑

        accept()仅标记事件状态，不会阻断函数内后续代码；ignore()将事件回传给上层对象

4. 三层拦截方案对比

拦截层级	重写函数	拦截范围	适用场景	推荐度
全局应用层	notify()	程序内所有对象全部事件	全局日志、全局权限拦截、统一监控	⭐⭐⭐⭐
窗口总分发层	event()	当前窗口及子控件全部事件	事件转发、统一过滤、自定义事件路由	⭐⭐⭐⭐
专项细分层	keyPressEvent/closeEvent 等	单一类型事件	常规业务按键、关闭弹窗、鼠标交互	⭐⭐⭐⭐⭐

五、三层事件拦截完整实现

1. 项目需求

1. 使用 Qt6.5 + CMake 构建 Demo4 工程
2. 自定义应用类继承 QApplication，重写 notify 实现全局事件打印
3. 主窗口重写 event 总事件分发函数，支持手动转发事件给子控件
4. 重写键盘按下事件：数字键输入拼接至标签，C 键清空标签文本
5. 重写窗口关闭事件，弹出确认弹窗，支持取消关闭窗口
6. 控制台实时打印事件接收对象与事件类型，直观观察事件分发流程

2. 文件结构说明

3. 代码分步解析

（2）全局应用 MyApplication：notify 全局事件拦截

头文件 myapplication.h

#ifndef MYAPPLICATION_H
#define MYAPPLICATION_H
// 原生Qt应用程序基类
#include <QApplication>
// 自定义应用程序，继承QApplication实现全局事件捕获
class MyApplication : public QApplication
{
    // 使用Qt元对象机制必备宏
    Q_OBJECT
public:
    // 构造函数，透传命令行参数给父类
    MyApplication(int argc, char *argv[]);
    // 重写notify虚函数，全局第一层事件拦截
    virtual bool notify(QObject *receiver, QEvent *e) override;
};
#endif // MYAPPLICATION_H

实现文件 myapplication.cpp

#include "myapplication.h"
// 控制台打印调试工具
#include <QDebug>
// 构造函数，调用父类QApplication构造
MyApplication::MyApplication(int argc, char *argv[]):
    QApplication(argc, argv){}
// 全局事件分发入口，所有控件事件都会先进入此函数
bool MyApplication::notify(QObject *receiver, QEvent *e)
{
    // receiver：事件接收的控件对象；e->type()：当前事件类型枚举
    qDebug() << "receiver: " << receiver << "/" << e->type();
    // 调用父类原生notify，将事件继续分发给对应控件处理
    // 注释此行会导致所有界面交互失效
    return QApplication::notify(receiver, e);
}

        notify是程序最顶层事件拦截点，能够监控软件内所有控件的全部交互事件，适合做全局日志、操作审计；必须保留父类 notify 调用，否则底层事件分发中断，按钮、输入框等控件无法正常响应操作。

（2）主窗口 Widget：event 总分发 + 按键 / 关闭专项事件

头文件 widget.h

#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
// Qt命名空间宏，隔离UI自动生成类
QT_BEGIN_NAMESPACE
namespace Ui {
class Widget;
}
QT_END_NAMESPACE
class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
    // 重写窗口总事件分发函数，第二层事件拦截
    bool event(QEvent *event) override;
    // 重写键盘按下专项事件，第三层细分事件
    void keyPressEvent(QKeyEvent *event) override;
    // 重写窗口关闭专项事件
    void closeEvent(QCloseEvent *event);
private:
    // UI界面控件管理指针
    Ui::Widget *ui;
};
#endif // WIDGET_H

实现文件 widget.cpp

#include "widget.h"
#include "ui_widget.h"
// 键盘事件专用头文件
#include <QKeyEvent>
// 弹窗提示框
#include <QMessageBox>
Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    // 加载渲染UI界面所有控件
    ui->setupUi(this);
}
Widget::~Widget()
{
    // 释放UI堆内存，防止内存泄漏
    delete ui;
}
// 窗口总事件入口：当前窗口+所有子控件事件都会进入该函数
bool Widget::event(QEvent *e)
{
    // 注释代码演示：将窗口按键事件转发给输入框处理
    /*
    if(e->type() == QEvent::KeyPress){
        // 手动把按键事件转发给lineEdit控件，由输入框处理按键
        return ui->lineEdit->event(e);
    }
    */
 #if 0
    // 早期版本直接在event中处理按键逻辑，不推荐，代码臃肿
    if(e->type() == QEvent::KeyPress){
        // 基类QEvent强制转换为键盘事件子类
        QKeyEvent *kevent = (QKeyEvent *)e;
        // 判断按下数字0-9
        if(kevent->key() >= Qt::Key_0  && kevent->key() <= Qt::Key_9){
            QString txt = ui->label->text();
            txt +=kevent->text();
            ui->label->setText(txt);
            return true; // 拦截事件，不再向下分发
        }
        // C键清空标签
        if(kevent->key() == Qt::Key_C){
            ui->label->setText("");
            return true;
        }
    }
#endif
    // 调用父类event，事件继续分发给keyPressEvent等专项函数
    return QWidget::event(e);
}
// 键盘按下专项事件函数，逻辑分离，代码更整洁
void Widget::keyPressEvent(QKeyEvent *kevent)
{
    // 按下数字0~9，拼接文本到label
    if(kevent->key() >= Qt::Key_0  && kevent->key() <= Qt::Key_9){
        QString txt = ui->label->text();
        txt +=kevent->text();
        ui->label->setText(txt);
        kevent->accept(); // 标记事件已处理，停止向上传递
    }
    // 按下C键清空标签内容
    if(kevent->key() == Qt::Key_C){
        ui->label->setText("");
        kevent->accept();
    }
    // 事件未被处理，忽略并向上传递给父窗口
    if(!kevent->isAccepted()){
        kevent->ignore();
    }
}
// 窗口关闭触发事件，实现退出二次确认
void Widget::closeEvent(QCloseEvent *event)
{
    // 弹出问答弹窗，选择是否退出
    if(QMessageBox::question(this, "提示", "是否退出？")==QMessageBox::Yes){
        event->accept(); // 接收关闭事件，允许关闭窗口
        close();
    }else{
        event->ignore(); // 忽略关闭事件，窗口保持打开
    }
}

        窗口层提供两种事件处理方式：event()统一拦截全部事件，适合事件转发、批量过滤；keyPressEvent、closeEvent细分事件函数适合单一业务逻辑开发，代码清晰易维护。通过accept()/ignore()控制事件冒泡，实现自定义交互逻辑。

（3）main.cpp：替换全局应用，启动事件循环

#include "widget.h"
// 引入自定义全局应用类
#include "myapplication.h"
// Qt原生应用基础类
#include <QApplication>
int main(int argc, char *argv[])
{
    // 替换原生QApplication为自定义MyApplication，开启全局notify事件拦截
    MyApplication a(argc, argv);
    // 创建主窗口实例
    Widget w;
    // 显示主窗口
    w.show();
    // 启动Qt事件循环，持续接收分发界面事件
    return a.exec();
}

        程序入口替换应用基类是开启全局事件监控的关键；若使用原生QApplication，notify全局拦截逻辑不会生效。程序运行后a.exec()阻塞主线程，循环接收鼠标、键盘、窗口关闭等所有事件。

4. 程序运行效果

1. 程序启动后主窗口展示，控制台持续打印所有控件对象与对应事件类型
2. 按下键盘数字键 0~9：窗口 label 标签实时拼接输入数字；按下 C 键清空标签文字
3. 点击窗口右上角关闭按钮，弹出确认弹窗：选 Yes 正常关闭程序，选 No 取消关闭
4. 取消注释event()内转发代码，窗口所有按键事件会转移至 lineEdit 输入框处理
5. 注释keyPressEvent内accept()，未匹配按键会向上传递至父窗口处理

六、核心知识点总结

        Qt 事件系统是界面交互底层基础，整套分发链路分为全局应用 notify、窗口 event 总分发、细分专项事件三层拦截，分层机制让事件拦截、过滤、转发具备极高灵活性。全局notify()可以监控程序全部对象的所有事件，多用于日志记录与全局统一管控；窗口event()作为当前窗口事件总入口，能够手动转发、拦截子控件事件，适合自定义事件路由逻辑；而keyPressEvent、closeEvent这类细分专用事件函数是日常业务开发首选，无需手动判断事件类型，代码结构清晰简洁。

        事件传递依靠accept()与ignore()控制冒泡规则，accept()标记事件已消费，终止向上传递；ignore()表示当前对象不处理，事件交由上层父控件接管。重写拦截函数时，若阻断事件需合理控制父类方法调用，缺失父类实现会导致 Qt 原生交互逻辑失效。

        开发时需根据业务场景选择拦截层级：需要全局监控选用重写 notify，需要统一转发窗口内事件选用 event 函数，仅处理单一按键、关闭等交互直接重写细分事件函数。三层拦截机制配合使用，能够灵活实现弹窗确认、全局日志、事件重定向等各类界面需求，是 Qt 界面开发必须掌握的底层核心机制。

转载自 CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/2403_84469788/article/details/163374558