Qt信号与槽机制入门详解：从基础语法到界面交互实战

一.信号与槽机制的引入

1.Qt 简介

1.1Qt 是什么？

Qt 是一个跨平台的 C++ 图形用户界面（GUI）应用程序开发框架，由挪威公司 Trolltech（现为 The Qt Company）开发。它不仅支持桌面应用（如 Windows、Linux、macOS），还广泛应用于嵌入式系统（如智能家居、工业控制）、移动应用（Android、iOS）以及物联网（IoT）领域。Qt 的核心优势在于其 “一次编写，多平台部署” 的能力，开发者只需维护一套代码即可适配不同操作系统。

应用领域

• 桌面应用：如 WPS Office、VLC 媒体播放器、Skype 等均基于 Qt 开发
• 嵌入式系统：智能家电、车载信息娱乐系统（IVI）、工业自动化设备（如 ABB 的控制系统）
• 移动应用：虽然市场份额较小，但 Qt 支持 Android 和 iOS 开发，如部分跨平台游戏和工具类应用
• 物联网与智能家居：用于开发设备控制界面和网关，支持多设备互联
• 游戏开发：通过 OpenGL 集成和高效的渲染引擎，支持 2D/3D 游戏界面设计

1.2 Qt 开发环境搭建（以 Qt Creator 为例）

步骤说明：

1. 下载安装包：访问 Qt 官网，选择 开源版本（LGPL 协议） 或商业版。
2. 运行安装程序：
   • 组件选择：
   ◦ Qt Creator（IDE）
   ◦ Qt 库（如 Qt 6.5.1 的 MSVC/MinGW 版本）
   ◦ 附加工具（如 Qt Designer 界面设计器）
   • 安装路径：建议使用英文路径（如 C:\Qt），避免中文字符导致的兼容性问题。
3. 配置环境变量（可选）：
   • 将 Qt 的 bin 目录加入系统 PATH，方便命令行调用。
4. 验证安装：
   • 打开 Qt Creator，创建 Qt Widgets Application 模板项目，编译运行默认的空白窗口程序。

关键提示：
• 若需开发移动应用，需额外勾选 Android/iOS 支持模块。
• 推荐使用 Qt 长期支持版本（LTS），如 Qt 6.4，以获取稳定性和长期维护。

2. C++ 与 Qt 的关联

2.1 Qt 对 C++ 的扩展与应用

Qt 在 C++ 基础上引入了以下扩展：

1. 元对象系统（Meta-Object System）：
   • 通过 元对象编译器（MOC） 生成代码，支持动态类型信息、信号与槽机制。
2. 信号与槽机制：取代传统回调函数，实现对象间松耦合通信（后文详述）。
3. 智能内存管理：
   • 父子对象树：父对象销毁时自动释放子对象，减少内存泄漏风险。
4. 跨平台抽象层：
   • 封装不同操作系统的底层 API（如窗口管理、文件系统），开发者无需关心平台差异。

2.2 面向对象编程在 Qt 中的体现

Qt 高度依赖面向对象设计原则：

1. 封装：
   • 每个 GUI 控件（如 QPushButton、QLineEdit）均为独立类，隐藏内部实现细节，仅暴露公共接口。
2. 继承：
   • 控件类继承自 QWidget，复用基类功能（如布局管理、事件处理）。
   • 例如：QMainWindow → QWidget → QObject。
3. 多态：
   • 通过虚函数重写实现控件自定义行为（如 paintEvent() 用于自定义绘图）。
4. 设计模式：
   • 观察者模式（信号与槽）、工厂模式（控件创建器）等被广泛应用。

3. 信号与槽机制的引入

3.1 传统回调函数的不足

在 C++ 中，回调函数常通过 函数指针 或 虚函数 实现，但存在以下问题：

1. 强耦合：调用者需明确知道回调函数的存在，修改时易引发连锁改动。
2. 类型不安全：函数指针易因参数类型或数量不匹配导致运行时错误。
3. 扩展性差：一个事件难以动态绑定多个处理函数。

3.2 信号与槽机制解决的问题

Qt 的 信号（Signal） 与 槽（Slot） 机制通过以下特性实现解耦：

1. 声明式绑定：
   • 信号声明为类的成员函数（无需实现），槽可为任何成员函数。
   • 示例：

connect(button, &QPushButton::clicked, this, &MyClass::onButtonClicked);

2. 动态连接：
   • 支持运行时动态绑定或解绑信号与槽。
3. 线程安全：
   • 支持跨线程通信（通过 Qt::QueuedConnection 模式）。
4. 类型安全：
   • 编译器检查信号与槽的参数类型和数量是否匹配。

对比优势：

二、信号与槽的基本概念

一、信号（Signal）的概念

1. 信号的定义

• 什么是信号
  在 Qt 中，信号用来表示对象的某种“事件”或“状态变化”。当事件发生时，该对象会“发射（emit）”一个信号，通知可能关心这个事件的其它对象。
• 信号的用途
  信号并不关心谁会接收，只是单纯地表示“我这里发生了某件事”。这实现了发送者和接收者之间的解耦，使得你可以灵活地在不同对象之间进行通信。

2. 信号的声明

在类定义中，使用 signals: 关键字声明一个或多个信号。常见语法如下：

#include <QObject>

class MyObject : public QObject
{
    Q_OBJECT  // 需要 Q_OBJECT 宏，才能让 MOC 识别该类的信号和槽

public:
    explicit MyObject(QObject *parent = nullptr);

signals:
    // 声明一个信号，不需要函数体
    void dataChanged(int newValue);

    // 也可以声明带多个参数的信号
    void messageEmitted(const QString &text, bool urgent);
};

注意

• 信号的声明类似函数声明，但没有函数体。
• 在 Qt 5/6 中，信号默认被编译器视作 protected 成员，但也可手动写成 public signals:。
• 只有继承自 QObject 并包含 Q_OBJECT 宏的类，才能使用 signals: 关键字。

3. 信号的触发

• 手动触发
  在类的实现中，可以使用 emit 关键字来发射信号。例如：

void MyObject::someMethod(int value)
{
    // 当某个条件满足时，发射 dataChanged 信号
    if (value != m_oldValue) {
        m_oldValue = value;
        emit dataChanged(value); // 触发 signal
    }
}

• 内置触发
  对于 Qt 内置的控件（如 QPushButton），很多信号在特定事件发生时自动触发，比如点击按钮时会自动发射 clicked() 信号。无需手动 emit。

小结：信号不需要具体实现，它只是在运行时通过 MOC 系统生成相应的元对象代码。我们只需在代码里写 emit signalName(...)，就可以让该信号发出。

二、槽（Slot）的概念

1. 槽的定义

• 什么是槽
  槽（Slot）是一个普通的成员函数，但被标记为专门用来接收信号。当对应的信号被发射后，若信号和槽之间建立了连接（connect），槽函数就会被自动调用。
• 槽与回调函数
  在传统 C/C++ 中，如果要在事件发生时调用某个函数，往往需要写回调函数并将其注册到某处。槽的概念与之类似，但更灵活且与 Qt 的事件系统深度结合。

2. 槽的声明

在类中使用 public slots:、protected slots: 或 private slots: 来声明槽函数。例如：

#include <QObject>
#include <QDebug>

class MyObject : public QObject
{
    Q_OBJECT

public:
    explicit MyObject(QObject *parent = nullptr);

signals:
    void dataChanged(int newValue);

public slots:
    // 声明一个槽函数，用于处理 dataChanged 信号
    void onDataChanged(int value);

private slots:
    // 也可以声明私有槽函数
    void someInternalSlot();
};

访问权限：

• public slots: 意味着外部对象也可显式调用该槽；
• private slots: 则只允许本类或友元类直接调用，但信号仍可触发它。
• 对于大多数场景，我们通常使用 public slots: 或 private slots:。

3. 槽的实现

与普通成员函数一样，在 .cpp 文件中实现槽函数的具体逻辑：

#include "myobject.h"

MyObject::MyObject(QObject *parent)
    : QObject(parent)
    , m_oldValue(0)
{}

void MyObject::onDataChanged(int value)
{
    qDebug() << "Slot onDataChanged called with value:" << value;
    // 在这里处理数据变化，比如更新界面、存档等
}

void MyObject::someInternalSlot()
{
    // 仅供内部使用的槽
    qDebug() << "Private slot triggered!";
}

注意：

• 槽函数在声明和实现上并没有太大区别，只是需要在类头文件中位于 slots: 区域。
• 槽可以有任意类型和数量的参数，但需要与对应信号的参数列表匹配或兼容（如信号有 2 个参数，则槽可以有 2 个或更少参数，且类型需兼容）。
• 槽函数既可以是 void 返回值，也可以是其他返回值类型，但通常不建议在槽中返回值，因为信号触发后并不期望有同步返回。

三、代码示例：自定义信号与槽

下面给出一个简短的示例，演示如何在自定义类中声明信号与槽，并手动发射信号。

myobject.h

#ifndef MYOBJECT_H
#define MYOBJECT_H

#include <QObject>

class MyObject : public QObject
{
    Q_OBJECT
public:
    explicit MyObject(QObject *parent = nullptr);

    // 用于模拟某些数据变化
    void setValue(int newValue);

signals:
    // 自定义信号
    void valueChanged(int newValue);

public slots:
    // 自定义槽
    void onValueChanged(int value);

private:
    int m_value;
};

#endif // MYOBJECT_H

myobject.cpp

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

MyObject::MyObject(QObject *parent)
    : QObject(parent), m_value(0)
{
}

void MyObject::setValue(int newValue)
{
    if (newValue != m_value) {
        m_value = newValue;
        // 当数值发生变化时，发射 valueChanged 信号
        emit valueChanged(m_value);
    }
}

void MyObject::onValueChanged(int value)
{
    // 这里是槽函数的实现
    qDebug() << "Slot onValueChanged triggered with value:" << value;
}

main.cpp（简易演示）

#include <QCoreApplication>
#include "myobject.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyObject senderObj;
    MyObject receiverObj;

    // 建立信号与槽的连接：senderObj 的 valueChanged -> receiverObj 的 onValueChanged
    QObject::connect(&senderObj, &MyObject::valueChanged,
                     &receiverObj, &MyObject::onValueChanged);

    // 手动调用 setValue，会触发 emit valueChanged(...)
    senderObj.setValue(42); // receiverObj.onValueChanged(42) 将被自动调用

    return a.exec();
}

• 当 senderObj.setValue(42) 被调用后，valueChanged(42) 信号就会被发射。
• 因为我们用 connect(...) 将 valueChanged 与 onValueChanged 关联，所以 receiverObj 的槽函数就会执行，输出相应的调试信息。

三、信号与槽的连接

下面将介绍信号与槽的连接，包括如何使用 QObject::connect() 进行基本连接，以及不同连接类型在多线程或特殊场景下的作用和区别，并通过简要示例帮助理解。

一、基本连接方式

在 Qt 中，最常见的做法是使用 QObject::connect() 来将发送者对象的信号与接收者对象的槽进行关联（连接）。一旦连接建立，当信号被发射时，槽函数就会被自动调用。

1. connect 函数的常见写法

自 Qt 5 开始，官方推荐使用基于函数指针的连接方式，语法如下：

// connect(sender, &SenderClass::signalName,
//         receiver, &ReceiverClass::slotName,
//         [可选的连接类型]);

• sender：发射信号的对象指针
• &SenderClass::signalName：信号的指针，例如 &QPushButton::clicked
• receiver：接收信号、执行槽的对象指针
• &ReceiverClass::slotName：槽函数的指针，例如 &MyWidget::onButtonClicked
• 连接类型（可选）：一个枚举值，默认为 Qt::AutoConnection，稍后会详细介绍

旧式写法
旧式写法使用 SIGNAL/ SLOT 宏，如 SIGNAL(clicked()) 和 SLOT(onButtonClicked())，这种宏在编译时不做检查，易出现拼写错误且调试不便。建议在新项目中使用基于函数指针的写法。

2. connect 的参数解释

1. 发送者对象（sender）
   通常是一个继承自 QObject 的对象，例如按钮（QPushButton）、计时器（QTimer）、自定义类等。
2. 信号（signal）
   • 指向某个类中的信号成员函数指针，如 &QPushButton::clicked
   • 当这个信号被发射（如按钮被点击），就会触发连接的槽。
3. 接收者对象（receiver）
   • 继承自 QObject 的对象，用于实现槽函数。
   • 当信号触发时，会调用此对象的槽函数。
4. 槽（slot）
   • 指向某个类的槽函数成员，如 &MyWindow::onButtonClicked
   • 当信号被发射，且满足一定条件时（同一线程或通过事件循环），就会执行槽函数。

3. 简单的连接示例

下面演示一个按钮点击时触发自定义槽的场景：

#include <QApplication>
#include <QPushButton>
#include <QMessageBox>

class MyWindow : public QWidget
{
    Q_OBJECT
public:
    MyWindow(QWidget *parent = nullptr) : QWidget(parent)
    {
        resize(300, 200);

        QPushButton *btn = new QPushButton("Click Me", this);
        btn->setGeometry(100, 80, 100, 30);

        // 使用新式写法：函数指针方式
        connect(btn, &QPushButton::clicked,
                this, &MyWindow::onButtonClicked);
    }

private slots:
    void onButtonClicked()
    {
        QMessageBox::information(this, "提示", "按钮被点击了！");
    }
};

• 当用户点击按钮时，QPushButton 内部会自动发射 clicked() 信号，onButtonClicked() 槽函数被调用，弹出一个对话框。

二、连接类型

QObject::connect() 的第五个可选参数是连接类型，常见有以下几种枚举值（定义在 Qt::ConnectionType 中）：

1. Qt::AutoConnection（默认）
   • 自动连接，Qt 会根据信号发送者和接收者所在线程自动选择是直接调用还是放到事件队列里执行。
   • 如果发送者和接收者在同一个线程，则等效于 Qt::DirectConnection；若不在同一线程，则等效于 Qt::QueuedConnection。
   • **大多数情况下都可以用默认的 ****AutoConnection**。
2. Qt::DirectConnection
   • 直接连接，当信号发射时，立即在当前线程调用槽函数。
   • 适用于发送者与接收者在同一个线程，并且希望信号触发时就立刻执行槽函数的场景。
   • 若在多线程场景中使用 DirectConnection，且信号发送者线程与接收者线程不同，则会带来线程安全问题，需要开发者手动保证线程同步。
3. Qt::QueuedConnection
   • 队列连接，信号发射后并不立即执行槽函数，而是将该调用封装为一个事件，放入接收者对象所在线程的事件队列中，等待事件循环调度后再执行。
   • 常用于跨线程通信，避免多线程的直接竞争。发送者与接收者不在同一线程时，信号会排队等待接收者线程的事件循环来调用。
4. 其他类型（简单了解）
   • Qt::BlockingQueuedConnection：和 QueuedConnection 类似，但会阻塞信号发射者线程，直到槽函数执行完毕才返回，需在多线程中小心使用。
   • Qt::UniqueConnection：可与其他枚举值按位或，如 Qt::AutoConnection | Qt::UniqueConnection，表示如果已存在相同信号与槽的连接则不重复连接。

连接类型的使用场景

• 单线程 GUI 常见场景
  通常用默认 Qt::AutoConnection 或不指定（即 AutoConnection）。此时发送者和接收者都在主线程，相当于直接调用。
• 多线程
  • 如果想让槽函数在接收者的线程中执行，需确保接收者对象创建于该线程，且使用 AutoConnection 或 QueuedConnection。
  • 如果需要跨线程时立即调用槽函数（通常不建议），可指定 DirectConnection，但要自行保证线程安全。

三、示例：自定义连接类型

以下代码演示了使用自定义连接类型的方式：

#include <QCoreApplication>
#include <QThread>
#include <QDebug>

class Worker : public QObject
{
    Q_OBJECT
public:
    explicit Worker(QObject *parent = nullptr) : QObject(parent) {}

signals:
    void dataReady(const QString &data);

public slots:
    void doWork()
    {
        // 模拟一些处理
        QString result = "Hello from Worker thread";
        emit dataReady(result);
    }

    void handleData(const QString &data)
    {
        // 槽函数：处理 dataReady 信号
        qDebug() << "handleData called in thread:" << QThread::currentThread()
                 << "with data:" << data;
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Worker worker;
    QThread thread;
    worker.moveToThread(&thread);

    // 当 Worker 的 dataReady 发射时，还是由 Worker 自己的 handleData 来处理
    // 但连接类型指定为 QueuedConnection，确保在 worker 所在的线程事件循环中执行
    QObject::connect(&worker, &Worker::dataReady,
                     &worker, &Worker::handleData,
                     Qt::QueuedConnection);

    // 连接 main thread 的信号, 以便启动子线程中的 doWork
    QObject::connect(&thread, &QThread::started,
                     &worker, &Worker::doWork);

    thread.start();

    return a.exec();
}

#include "main.moc"

• 这里 dataReady 信号与 handleData 槽通过 Qt::QueuedConnection 连接，这意味着 handleData 会在 worker 所在的线程（子线程）的事件循环中执行。
• 当 thread.start() 时，会触发 started 信号，从而调用 worker.doWork()，进而发射 dataReady。然后队列事件调度 handleData 在同一子线程中执行。
• 如果改为 DirectConnection，则发射信号时会立即执行 handleData 函数，而此时若跨线程，就可能出现线程安全问题。

总结

1. QObject::connect()
   • 用于将一个对象的信号与另一个对象的槽关联；
   • 新式写法使用函数指针，更安全可读；
   • 典型形式：

connect(sender, &SenderClass::signalName,
        receiver, &ReceiverClass::slotName,
        Qt::ConnectionType);

2. 连接类型
   • Qt::AutoConnection：默认，单线程相当于直接调用，多线程相当于队列调用；
   • Qt::DirectConnection：立即调用槽，适用于同线程场景；
   • Qt::QueuedConnection：跨线程通信常用，发射信号后将槽函数放入接收者线程的事件循环执行；
   • 其它如 BlockingQueuedConnection、UniqueConnection 等用于特殊需求。
3. 常见示例
   • GUI 应用中按钮点击触发某函数：

connect(button, &QPushButton::clicked,
        this, &MyWidget::onButtonClicked);

- 多线程应用中跨线程传递数据： 

connect(sender, &SenderClass::signalData,
        receiver, &ReceiverClass::slotProcessData,
        Qt::QueuedConnection);

通过对连接方式和连接类型的理解，你就能在不同场景下灵活选择信号与槽的调用机制，实现对象间的通信与数据传递。

四、信号与槽的实际应用示例

下面我们继续讲解 信号与槽 在实际项目中的具体应用示例，包括常见的界面交互（如按钮点击、菜单选择）以及数据更新场景（如数据模型变化、界面控件状态变化）。这些示例能帮助你更直观地理解并掌握信号与槽的用法。

1. 界面交互示例

在图形界面应用中，最常见的场景便是“用户触发事件 → 界面做出响应”。Qt 提供了丰富的控件，每个控件都定义了一些常用信号，比如按钮的 clicked()、菜单选项的 triggered() 等。通过这些信号与自定义槽函数的连接，可以实现各种交互逻辑。

1) 按钮点击事件

示例需求：当用户点击按钮后，弹出一个提示对话框，同时更新界面上的某些信息。

实现步骤：

1. 在主窗口或对话框的构造函数中，创建按钮 QPushButton。
2. 通过 connect() 将按钮的 clicked() 信号与槽函数关联。
3. 在槽函数中执行弹窗操作或界面更新。

示例代码：

#include <QApplication>
#include <QPushButton>
#include <QMessageBox>
#include <QLabel>
#include <QVBoxLayout>

class MyWindow : public QWidget
{
    Q_OBJECT
public:
    MyWindow(QWidget *parent = nullptr) : QWidget(parent)
    {
        setWindowTitle("界面交互示例");
        resize(300, 150);

        // 创建按钮和标签
        QPushButton *btn = new QPushButton("点击我", this);
        QLabel *label = new QLabel("等待点击...", this);

        // 垂直布局
        QVBoxLayout *layout = new QVBoxLayout(this);
        layout->addWidget(btn);
        layout->addWidget(label);

        // 将按钮的 clicked 信号与槽函数连接
        connect(btn, &QPushButton::clicked,
                this, [=]() {
                    // 槽函数体：弹出提示对话框，更新标签文字
                    QMessageBox::information(this, "提示", "按钮被点击了！");
                    label->setText("按钮点击完成");
                });
    }
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    MyWindow w;
    w.show();
    return app.exec();
}

#include "main.moc"

• QPushButton::clicked 信号：当按钮被点击时发射。
• Lambda表达式（C++11 及以上）直接作为槽函数，简洁易读。
• 弹窗使用 QMessageBox::information，并且修改标签文字以反馈操作结果。

2) 菜单选择事件

示例需求：当用户在菜单栏中选择某个选项时，执行特定功能（例如打开文件、保存文件或退出程序）。

实现步骤：

1. 创建一个 QMenuBar，并向其中添加 QMenu 和 QAction。
2. 连接 QAction 的 triggered() 信号到对应的槽函数。
3. 在槽函数中实现打开文件或退出程序等操作。

示例代码（只演示核心部分）：

#include <QMainWindow>
#include <QMenuBar>
#include <QAction>
#include <QMessageBox>

class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    MainWindow(QWidget *parent = nullptr) : QMainWindow(parent)
    {
        // 创建菜单
        QMenu *fileMenu = menuBar()->addMenu("文件(&F)");
        QAction *openAction = new QAction("打开(&O)", this);
        QAction *exitAction = new QAction("退出(&Q)", this);

        fileMenu->addAction(openAction);
        fileMenu->addAction(exitAction);

        // 连接信号与槽
        connect(openAction, &QAction::triggered,
                this, &MainWindow::onOpenFile);
        connect(exitAction, &QAction::triggered,
                this, &MainWindow::onExit);
    }

private slots:
    void onOpenFile()
    {
        // 打开文件的逻辑
        QMessageBox::information(this, "提示", "你选择了【打开文件】操作！");
    }

    void onExit()
    {
        // 退出程序
        QMessageBox::information(this, "提示", "程序即将退出...");
        qApp->quit(); // 或 close();
    }
};

• QAction::triggered() 在菜单项或工具栏按钮被触发时发射。
• 在槽函数中编写实际的业务逻辑，如弹窗或文件操作。

2. 数据更新示例

除了界面上的交互操作，很多情况下我们需要在数据发生变化时自动更新界面，或者在界面操作改变数据时，通知底层逻辑处理。Qt 提供了数据模型与控件的分离机制（MVC/MVVM 思想），但最直观的例子是一个控件的值变化信号，从而更新其他控件或数据。

1) 数据模型变化信号

示例需求：当数据模型（如自定义类或 QAbstractItemModel）中的数据改变时，通知界面进行更新。

思路：

• 在自定义数据模型类中定义一个信号，如 dataChanged()。
• 当内部数据修改时，发射该信号，告知外部“数据已更新”。
• 界面（View）或其他逻辑（Controller）连接这个信号，在槽函数中进行 UI 刷新或其他操作。

示例代码（简化版，展示思路）：

class MyDataModel : public QObject
{
    Q_OBJECT
public:
    MyDataModel(QObject *parent = nullptr) : QObject(parent), m_value(0) {}

    void setValue(int val)
    {
        if (m_value != val) {
            m_value = val;
            emit dataChanged(m_value);
        }
    }

signals:
    void dataChanged(int newValue);

private:
    int m_value;
};

// 界面部分
class DataWidget : public QWidget
{
    Q_OBJECT
public:
    DataWidget(QWidget *parent = nullptr) : QWidget(parent)
    {
        // 假设 model 是外部传进来或者在构造函数里创建
        model = new MyDataModel(this);

        // Label 显示数据
        label = new QLabel("当前数据：0", this);

        // 当模型数据变化时，更新 label
        connect(model, &MyDataModel::dataChanged,
                this, &DataWidget::onDataChanged);

        // 设置布局略...
    }

    MyDataModel *model;

private slots:
    void onDataChanged(int newVal)
    {
        label->setText(QString("当前数据：%1").arg(newVal));
    }

private:
    QLabel *label;
};

• 当调用 model->setValue(123) 时，如果值真的发生变化，就会 emit dataChanged(123)。
• DataWidget 里连接了这个信号，一旦触发，就调用 onDataChanged(int newVal)，进而刷新标签文字。

2) 界面控件状态变化信号

示例需求：当滑块（QSlider）被拖动时，更新文本标签显示滑块的当前值。

实现步骤：

1. 创建一个 QSlider 和一个 QLabel；
2. 连接 QSlider::valueChanged(int) 信号到槽函数；
3. 在槽函数中使用 label->setText(...) 更新显示。

示例代码：

#include <QApplication>
#include <QWidget>
#include <QSlider>
#include <QLabel>
#include <QVBoxLayout>

class SliderWindow : public QWidget
{
    Q_OBJECT
public:
    SliderWindow(QWidget *parent = nullptr) : QWidget(parent)
    {
        resize(300, 150);

        QVBoxLayout *layout = new QVBoxLayout(this);
        slider = new QSlider(Qt::Horizontal, this);
        label = new QLabel("当前值: 0", this);

        layout->addWidget(slider);
        layout->addWidget(label);

        // 设置滑块范围
        slider->setRange(0, 100);

        // 连接滑块值变化信号
        connect(slider, &QSlider::valueChanged,
                this, &SliderWindow::onSliderValueChanged);
    }

private slots:
    void onSliderValueChanged(int value)
    {
        label->setText(QString("当前值: %1").arg(value));
    }

private:
    QSlider *slider;
    QLabel *label;
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    SliderWindow w;
    w.show();
    return app.exec();
}

#include "main.moc"

• 当用户拖动滑块时，QSlider 内部会发射 valueChanged(int) 信号；
• 连接的槽函数 onSliderValueChanged(int) 接收到新值后，用 label->setText 进行界面更新。

小结

1. 界面交互：
   • 常见的有按钮点击、菜单选择、复选框勾选、单选按钮切换等，都可以通过 clicked()、triggered() 等信号触发对应的槽函数执行操作。
   • 通过弹窗 (QMessageBox) 或更新标签 (QLabel) 等方式来反馈给用户。
2. 数据更新：
   • 当底层数据改变时，需要通知上层界面刷新（模型-视图模式）；
   • 当界面控件值变化（如滑块移动），也会发射对应信号，从而更新其他界面元素或内部数据结构。
3. 信号与槽的优势：
   • 让对象之间通信更松耦合；
   • 易于维护和扩展，只要信号与槽的函数签名一致，就可以灵活更改内部实现，而不影响外部使用。

1. 📜 [ 声明 ] 由于作者水平有限，本文有错误和不准确之处在所难免，
2. 本人也很想知道这些错误，恳望读者批评指正！
3. 我是：勇敢滴勇~感谢大家的支持！