Qt 信号与槽 [ 1 ]

1. 信号和槽概述

在 Qt 中，用户和控件的每次交互过程称为一个事件。比如 "用户点击按钮" 是一个事件，"用户关闭窗口" 也是一个事件。每个事件都会发出一个信号，例如用户点击按钮会发出 "按钮被点击" 的信号，用户关闭窗口会发出 "窗口被关闭" 的信号。

Qt 中的所有控件都具有接收信号的能力，一个控件还可以接收多个不同的信号。 对于接收到的每个信号，控件都会做出相应的响应动作。例如，按钮所在的窗口接收到 "按钮被点击" 的信号后，会做出 "关闭自己" 的响应动作；再比如输入框自己接收到 "输入框被点击" 的信号后，会做出 "显示闪烁的光标，等待用户输入数据" 的响应动作。在 Qt 中，对信号做出的响应动作就称之为槽【函数】 。

信号和槽是 Qt 特有的消息传输机制，它能将相互独立的控件关联起来。比如，"按钮" 和 "窗口" 本身是两个独立的控件，点击 "按钮" 并不会对 "窗口" 造成任何影响。通过信号和槽机制，可以将 "按钮" 和 "窗口" 关联起来，实现 "点击按钮会使窗口关闭" 的效果。

信号的本质

信号是由于用户对窗口或控件进行了某些操作，导致窗口或控件产生了某个特定事件，这时 Qt 对应的窗口类会发出某个信号，以此对用户的操作做出反应。因此，信号的本质就是事件。如：

按钮单击、双击
窗口刷新
鼠标移动、鼠标按下、鼠标释放
键盘输入

那么在 Qt 中信号是通过什么形式呈现给使用者的呢？

我们对哪个窗口进行操作，哪个窗口就可以捕捉到这些被触发的事件。
对于使用者来说触发了一个事件我们就可以得到 Qt 框架给我们发出的某个特定信号。
信号的呈现形式就是函数，也就是说某个事件产生了，Qt 框架就会调用某个对应的信号函数，通知使用者。

在 Qt 中信号的发出者是某个实例化的类对象。

槽的本质

槽（Slot）就是对信号响应的函数。 槽就是一个函数，与一般的 C++ 函数是一样的，可以定义在类的任何位置（public、protected 或 private），可以具有任何参数，可以被重载，也可以被直接调用（但是不能有默认参数）。槽函数与一般的函数不同的是：槽函数可以与一个信号关联，当信号被发射时，关联的槽函数被自动执行。

说明

（1）信号和槽机制底层是通过函数间的相互调用实现的。每个信号都可以用函数来表示，称为信号函数 ；每个槽也可以用函数表示，称为槽函数 。例如："按钮被按下" 这个信号可以用 clicked() 函数表示，"窗口关闭" 这个槽可以用 close() 函数表示，假如使用信号和槽机制实现："点击按钮会关闭窗口" 的功能，其实就是 clicked() 函数调用 close() 函数的效果。

（2）信号函数和槽函数通常位于某个类中，和普通的成员函数相比，它们的特别之处在于：

信号函数用 signals 关键字修饰，槽函数用 public slots、protected slots 或者 private slots 修饰。signals 和 slots 是 Qt 在 C++ 的基础上扩展的关键字，专门用来指明信号函数和槽函数；
信号函数只需要声明，不需要定义（实现），而槽函数需要定义（实现）。

💡 信号函数的定义是 Qt 自动在编译程序之前生成的，编写 Qt 应用程序的程序员无需关注。这种自动生成代码的机制称为元编程（Meta Programming） ，这种操作在很多场景中都能见到。

2. 信号和槽的使用

2.1 连接信号和槽

在 Qt 中，QObject 类提供了一个静态成员函数 connect()，该函数专门用来关联指定的信号函数和槽函数。

💡 QObject 是 Qt 内置的父类。Qt 中提供的很多类都是直接或者间接继承自 QObject。这一点的设定和 Java 是非常相似的。

connect() 函数原型：

cpp 复制代码

template <typename Func1, typename Func2>
static QMetaObject::Connection connect(
    const typename QtPrivate::FunctionPointer<Func1>::Object *sender,
    Func1 signal,          // 函数指针！
    const typename QtPrivate::FunctionPointer<Func2>::Object *receiver,
    Func2 slot,            // 函数指针！
    Qt::ConnectionType type = Qt::AutoConnection
);

参数说明：

sender：信号的发送者；
signal：发送的信号（信号函数）；
receiver：信号的接收者；
method：接收信号的槽函数；
type：用于指定关联方式，默认的关联方式为 Qt::AutoConnection，通常不需要手动设定。

代码示例：在窗口中设置一个按钮，当点击 "按钮" 时关闭 "窗口".

cpp 复制代码

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    QPushButton* btn = new QPushButton("关闭窗口", this);
    resize(800, 600);

    // 关联信号和槽：实现点击 "按钮" 关闭 "窗口"
    connect(btn, &QPushButton::clicked, this, &QWidget::close);
}

2.2 查看内置信号和槽

系统自带的信号和槽通常是通过 "Qt 帮助文档 " 来查询。

如上述示例，要查询 "按钮" 的信号，在帮助文档中输入：QPushButton，

首先可以在 "Contents" 中寻找关键字 signals，
如果没有找到，继续去父类中查找。因此我们去他的父类 QAbstractButton 中继续查找关键字 signals，

Signals

cpp 复制代码

void clicked(bool checked = false)
void pressed()
void released()
void toggled(bool checked)

这里的 clicked() 就是要找的信号。槽函数的寻找方式和信号一样，只不过它的关键字是 slot。

2.3 通过 Qt Creator 生成信号槽代码

Qt Creator 可以快速帮助我们生成信号槽相关的代码。

代码示例：在窗口中设置一个按钮，当点击 "按钮" 时关闭 "窗口"。

新建项目，如下图为新建完成之后所包含的所有文件；

注意：创建时要生成设计文件；

双击 widget.ui 文件，进入 UI 设计界面；

在 UI 设计窗口中拖入一个 "按钮"，并且修改 "按钮" 的名称及字体大小等；

可视化生成槽函数；

先选中按钮组件，鼠标右键
选择 "转到槽..."
对于按钮来说，当点击时发送的信号是：clicked()，所以此处选择：clicked()

注意：对于普通按钮来说，使用 clicked 信号即可。clicked(bool) 没有意义的，具有特殊状态的按钮（比如复选按钮）才会用到 clicked(bool)。

自动生成槽函数原型框架；

（1）在 widget.h 头文件中自动添加槽函数的声明：

cpp 复制代码

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>

QT_BEGIN_NAMESPACE
class Widget;
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private slots:
    void on_pushButton_clicked(); // 在头文件widget.h中自动添加槽函数声明

private:
    Ui::Widget *ui;
};
#endif // WIDGET_H

（2）在 widget.cpp 中自动生成槽函数定义：

cpp 复制代码

#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
}

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

// 自动生成的槽函数原型框架
void Widget::on_pushButton_clicked()
{

}

说明： 自动生成槽函数的名称有一定的规则。槽函数的命名规则为：on_XXX_SSS，其中：

💡 按照这种命名风格定义的槽函数，就会被 Qt 自动的和对应的信号进行连接。但是咱们日常写代码的时候，除非是 IDE 自动生成，否则最好还是不要依赖命名规则，而是显式使用 connect 更好。 一方面显式 connect 可以更清晰直观的描述信号和槽的连接关系。另一方面也防止信号或者槽的名字拼写错误导致连接失效。（当然，是配置优于约定，还是约定大于配置，哪种更好，这样的话题业界尚存在争议，此处我个人还是建议优先考虑显式 connect）

以 on 开头，中间使用下划线连接起来；

XXX 表示的是对象名（控件的 objectName 属性）。

SSS 表示的是对应的信号。如：on_pushButton_clicked()，pushButton 代表的是对象名，clicked 是对应的信号。

在槽函数定义中添加要实现的功能，实现关闭窗口的效果：

cpp 复制代码

void Widget::on_pushButton_clicked()
{
    this->close(); // 添加关闭窗口的代码
}

3. 自定义信号和槽

3.1 基本语法

在 Qt 中，允许自定义信号的发送方以及接收方，即可以自定义信号函数 和槽函数 。但是对于自定义的信号和槽函数有一定的书写规范。

1、自定义信号函数书写规范

（1）自定义信号函数必须写到 signals: 下；

（2）返回值为 void，只需要声明，不需要实现；

（3）可以有参数，也可以发生重载；

2、自定义槽函数书写规范

（1）早期的版本中要求槽函数必须写到 public slots: 下，但是现在高级版本的 Qt 允许写到类的 public 作用域或者全局下；

（2）返回值为 void，需要声明，也需要实现；

（3）可以有参数，可以发生重载；

3、发送信号

使用 emit 关键字发送信号。emit 是一个空的宏。emit 其实是可选的，没有什么含义，只是为了提醒开发人员。

示例 1

在 widget.h 中声明自定义的信号和槽：

cpp 复制代码

#include <QWidget>

class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    void EmitSignal();

signals:
    void MySignal(); // 信号声明

public slots:
    void MySlots(); // 槽声明
};
#endif // WIDGET_H

在 widget.cpp 中实现槽函数，并且关联信号和槽：

cpp 复制代码

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

Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    // 关联自定义的信号和槽
    connect(this, &Widget::MySignal, this, &Widget::MySlots);
    // 发送信号；当信号触发时就会自动调用槽函数
    EmitSignal();
}

/******** 自定义槽函数的实现 ********/
void Widget::MySlots()
{
    qDebug() << "我的信号和槽";
}

/******** 编写函数实现信号的触发 ********/
void Widget::EmitSignal()
{
    emit MySignal(); // emit关键字发送信号
}

**注意：**关联信号和槽与发送信号的顺序不能颠倒。原因是，首先关联信号和槽，当检测到信号发射之后就会执行关联的槽函数。反之，若先发射信号，此时还没有关联槽函数，当信号发射之后槽函数不会响应。【所以我们自定义信号和槽，必须要在合适的位置进行关联】

示例 2：当老师说 "上课了"，学生们就 "回到座位，开始学习"。

在源文件中新建两个类，一个是老师类，一个是学生类；

选中项目名称，鼠标右键 ------> add new...
选择 C++ Class，基类选择 QObject，分别创建 Teacher 和 Student 类。

注意：在 Qt 中新建类时，要选择新建类的父类。

显然，当前项目中还没啥类适合做新类的父类，同时新的类也不是一个 "窗口" 或者 "控件"。这种情况一般选择 QObject 作为基类。

这样做的好处是这个新类的对象可以搭配 Qt 的对象树机制，便于对象的正确释放。

也就是说：只要你给 QPushButton*（或任何 Qt 控件）指定父对象【父窗口】为 this，你就 100% 不需要手动写 delete，也不需要写析构函数释放它！ Qt 会自动帮你释放，绝对不会内存泄漏！

在 teacher.h 中声明信号函数：

cpp 复制代码

#ifndef TEACHER_H
#define TEACHER_H

#include <QObject>

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

signals:
    void MySignal(); // 自定义信号函数声明
};
#endif // TEACHER_H

在 student.h 中声明槽函数：

cpp 复制代码

#ifndef STUDENT_H
#define STUDENT_H

#include <QObject>

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

public slots:
    void StartStudy(); // 自定义槽函数声明
};
#endif // STUDENT_H

在 widget.h 中实例化 "老师类对象" 和 "学生类对象"：

cpp 复制代码

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include "teacher.h"
#include "student.h"

class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();
    void EmitSignal(); // 信号发送函数

private:
    Teacher *tch; // 发送信号的对象
    Student *stu; // 接收信号的对象
};
#endif // WIDGET_H

在 student.cpp 中实现槽函数：

cpp 复制代码

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

Student::Student(QObject *parent) : QObject(parent)
{

}

/******** 自定义槽函数实现 ********/
void Student::StartStudy()
{
    qDebug() << "回到座位，开始学习";
}

在 widget.cpp 中连接自定义信号和槽：

cpp 复制代码

#include "widget.h"
#include "teacher.h"
#include "student.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    this->tch = new Teacher(this);
    this->stu = new Student(this);
    connect(tch, &Teacher::MySignal, stu, &Student::StartStudy);
    EmitSignal();
}

void Widget::EmitSignal()
{
    emit tch->MySignal();
}

Widget::~Widget()
{
    delete tch;
    delete stu;
}

示例 3：老师点击 "按钮" 触发学生上课

在 widget.cpp 中，将按钮的 clicked 信号与老师的 MySignal 信号关联：

cpp 复制代码

#include "widget.h"
#include "ui_widget.h"
#include <QPushButton>

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);
    this->tch = new Teacher(this);
    this->stu = new Student(this);
    QPushButton *btn = new QPushButton("上课了", this);
    btn->move(100,100);

    connect(tch, &Teacher::MySignal, stu, &Student::StartStudy);
    connect(btn, &QPushButton::clicked, tch, &Teacher::MySignal);
}

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

调用链是：

cpp 复制代码

用户点击按钮
   ↓
触发按钮自带信号：clicked()
   ↓
clicked() 触发 → 老师的 MySignal()
   ↓
MySignal() 触发 → 学生的 StartStudy() 槽函数
   ↓
执行槽函数里的代码

3.2 带参数的信号和槽

Qt 的信号和槽也支持带有参数，同时也可以支持重载。 此处我们要求，信号函数的参数列表要和对应连接的槽函数参数列表一致。 此时信号触发，调用到槽函数的时候，信号函数中的实参就能够被传递到槽函数的形参当中。

💡 通过这样的机制，就可以让信号给槽传递数据了。

示例 1：重载信号槽

（1）在 "widget.h" 头文件中声明重载的信号函数以及重载的槽函数；如下图所示：

cpp 复制代码

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>

class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

    void EmitSignal(); // 信号发射函数

signals:
    void MySignal();       // 信号函数声明
    void MySignal(QString); // 发生重载的信号函数声明

public slots:
    void MySlot();       // 槽函数声明
    void MySlot(QString); // 发生重载的槽函数声明
};

#endif // WIDGET_H

（2）在 "Widget.cpp" 文件实现重载槽函数以及连接信号和槽。注意：在定义函数指针时要指明函数指针的作用域。

cpp 复制代码

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

Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    // 注意：在指针前面一定要加上类作用域说明符，说明该指针指向哪个类的成员函数
    void (Widget::*Signal_p)(QString) = &Widget::MySignal; // 定义函数指针指向信号函数
    void (Widget::*Slot_p)(QString) = &Widget::MySlot;     // 定义函数指针指向槽函数
    connect(this, Signal_p, this, Slot_p); // 连接信号与槽
    EmitSignal(); // 发射信号
}

void Widget::MySlot()
{
    qDebug() << "MySlot()被调用";
}

void Widget::MySlot(QString str)
{
    qDebug() << "MySlot(QString str)被调用" << str;
}

void Widget::EmitSignal()
{
    emit MySignal("Hello");
}

（3）执行结果如下图所示：

cpp 复制代码

MySlot(QString str)被调用 "Hello"

示例 2：信号槽参数列表匹配规则

1、在 "widget.h" 头文件中声明信号和槽函数；

cpp 复制代码

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QString>

class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

    void EmitSignal(); // 信号发射函数

signals:
    void MySignal(QString); // 信号函数参数为QString类型

public slots:
    void MySlot(QString); // 槽函数参数为QString类型
};

#endif // WIDGET_H

2、在 "widget.cpp" 文件中实现槽函数以及连接信号和槽；

cpp 复制代码

#include "widget.h"
#include <QDebug>
#include <QString>

Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    connect(this, &Widget::MySignal, this, &Widget::MySlot);
    EmitSignal(); // 发射信号
}

void Widget::MySlot(QString str)
{
    str = "Hello";
    qDebug() << str;
}

void Widget::EmitSignal()
{
    QString str = "Hello";
    emit MySignal(str); // 发射信号
}

其实信号的参数个数可以多于槽函数的参数个数，但是槽的参数个数不能多于信号参数个数。但是实际开发中最好还是保持参数个数也能匹配一致。

示例 3：

1、在 "widget.h" 头文件中声明信号和槽函数；

cpp 复制代码

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QString>

class Widget : public QWidget
{
    Q_OBJECT
public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

    void EmitSignal(); // 信号发射函数

signals:
    void MySignal(QString); // 信号函数有一个参数

public slots:
    void MySlot(); // 槽函数无参数
};

#endif // WIDGET_H

2、在 "widget.cpp" 文件中实现槽函数以及连接信号和槽；

cpp 复制代码

#include "widget.h"
#include <QDebug>
#include <QString>

Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    connect(this, &Widget::MySignal, this, &Widget::MySlot);
    EmitSignal(); // 发射信号
}

void Widget::MySlot()
{
    qDebug() << "Hello";
}

void Widget::EmitSignal()
{
    QString str = "Hello";
    emit MySignal(str); // 发射信号
}