信号和槽概述
在 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)。这种操作在很多场景中都能见到
信号和槽的使用
connect函数
在Qt中,connect()
函数是一个核心功能,它用于将信号与相应的槽函数连接起来。当信号被发射时,所有与之连接的槽函数都将被调用,这是Qt的信号与槽机制的基础。
connect()
函数通常有几种不同的重载形式,主要的区别在于参数的类型和数量。以下是一些常用的重载形式:
- 使用函数指针的新式连接(Qt 5开始引入,更加类型安全):
QMetaObject::Connection QObject::connect(
const QObject *sender,
void (SenderClass::*signal)(SignalArgs...),
const QObject *receiver,
void (ReceiverClass::*method)(SlotArgs...),
Qt::ConnectionType type = Qt::AutoConnection
);
在这个原型中,sender
和receiver
是对象的指针,指向发出信号的对象和接收信号的对象。函数指针signal
是发送者类的成员函数指针,表示哪个信号将被发出。函数指针method
是接收者类的成员函数指针,表示哪个槽函数将被执行。参数type
指定了信号和槽的连接类型。
2.SIGNAL和SLOT宏原型(传统连接,不推荐):
QMetaObject::Connection QObject::connect(
const QObject *sender,
const char *signal,
const QObject *receiver,
const char *method,
Qt::ConnectionType type = Qt::AutoConnection
);
这种连接方式使用了 Qt 的元对象系统。SIGNAL
和SLOT
宏将信号和槽函数转换为字符串,在运行时进行匹配。这个方法不如函数指针类型安全,容易出错,因为编译器不能在编译时进行检查。
例如:
connect(sender, SIGNAL(signalName(arguments)), receiver, SLOT(slotName(arguments)));
每个原型中的Qt::ConnectionType
的默认值为Qt::AutoConnection
,表示 Qt 运行时会选择最合适的方式来执行信号和槽之间的连接,通常是基于它们是否处于同一个线程。
代码示例:在窗口中设置⼀个按钮,当点击 “按钮” 时关闭 “窗口” 。
//widget.cpp
#include "widget.h"
#include "ui_widget.h"
#include <QPushButton>
Widget::Widget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::Widget)
{
ui->setupUi(this);
QPushButton *btn = new QPushButton(this); //创建按钮
btn->setText("关闭窗口");
resize(800,600); //调整Widget窗口大小
// 关联信号和槽:实现点击"按钮"后关闭"窗口"
connect(btn,&QPushButton::clicked,this,&Widget::close);
}
Widget::~Widget()
{
delete ui;
}
3.Lambda表达式方式
在 Qt 中使用 Lambda 表达式可以让信号和槽的连接更加灵活和简洁。自从C++11起,Qt 开始支持使用 Lambda 表达式连接信号和槽。这意味着不再需要定义和声明槽函数,而可以直接在连接时指定一个Lambda表达式来处理信号。
下面是一个使用Lambda表达式的例子:
假设有一个按钮(QPushButton),当按钮被点击时,在控制台上打印“Button clicked”。
QPushButton *button = new QPushButton("Press me");
// 使用Lambda表达式连接信号和槽
connect(button, &QPushButton::clicked, []() {
qDebug() << "Button clicked";
});
Lambda 表达式写在 connect()
函数的第三个参数位置,它直接定义了当信号被触发时将要执行的代码块。可以在 Lambda 表达式中捕获所需的变量、调用成员函数或执行任何其他可复制或可访问的代码。
Lambda 表达式中的捕获列表允许指定需要在 Lambda 表达式体内使用的外部变量。例如,如果想在 Lambda 中使用窗口类中的成员变量,可以使用捕获列表来捕获this
指针:
// 假设在MainWindow类的某个成员函数中
connect(button, &QPushButton::clicked, [this]() {
this->someMemberFunction();
});
另外,如果需要传递信号的参数到 Lambda 表达式,可以这样做:
connect(button, &QPushButton::clicked, [&](bool checked) {
if (checked) {
qDebug() << "Button is checked";
} else {
qDebug() << "Button is unchecked";
}
});
在上面的例子中,假设clicked
信号传递了一个布尔值,Lambda表达式就可以接收这个参数并在其内部使用。
使用 Lambda 表达式的优势在于,它可以非常方便地实现简洁的事件处理逻辑,而不需要在类中专门定义槽函数。这在处理简单的信号时非常有用。但是,需要注意的是,Lambda 表达式可能会导致对象的生命周期问题:如果 Lambda 捕获了某些对象的指针或引用,而那些对象在 Lambda 执行时已经被销毁,那么程序可能会崩溃。因此,当处理与对象生命周期相关的逻辑时,要特别小心。
查看内置信号和槽
系统自带的信号和槽通常是通过 “Qt 帮助文档” 来查询。
如上述示例,要查询“按钮”的信号,在帮助文档中输入:QPushButton,
- 首先可以在“Contents"中寻找关键字 signals,
- 如果没有找到,继续去父类中查找。因此我们去他的父类 QAbstractButton 中继续查找关键字 signals,
这里的 clicked() 就是要找的信号。槽函数的寻找方式和信号一样,只不过它的关键字是 slot 。
通过 Qt Creator 生成信号槽代码
Qt Creator 可以快速帮助我们生成信号槽相关的代码
代码示例:在窗口中设置一个按钮,当点击“按钮”时关闭“窗口”
1、新建项目,如下图为新建完成之后所包含的所有文件:
2、双击 widget.ui文件,进入 UI 设计界面
3、在 UI 设计窗口中拖入一个“按钮”,并且修改“按钮”的名称及字体大小等;
4、可视化生成槽函数;
当单击“转到槽…"之后,出现如下界面:对于按钮来说,当点击时发送的信号是: clicked(),所以此处选择: clicked()
对于普通按钮来说,使用 clicked 信号即可。clicked(bool) 没有意义的。具有特殊状态的按钮(比如复选按钮)才会用到 clicked(bool)。
5、自动生成槽函数原型框架
(1) 在“widget.h”头文件中自动添加槽函数的声明
说明:
自动生成槽函数的名称有一定的规则。槽函数的命名规则为:on_XXX_SSS,其中:
1、以”on”开头,中间使用下划线连接起来;
2、"XXX”表示的是对象名(控件的 objectName
属性)。
3、"SSS”表示的是对应的信号。
如:“on_pushButton_clicked()”,pushButton 代表的是对象名,clicked 是对应的信号。
按照这种命名风格定义的槽函数,就会被 Qt 自动的和对应的信号进行连接。
但是日常写代码的时候,除非是 IDE 自动生成,否则最好还是不要依赖命名规则,而是显式使用 connect 更好。
一方面显式 connect 可以更清晰直观的描述信号和槽的连接关系。
另一方面也防止信号或者槽的名字拼写错误导致连接失效。
(2) 在“widget.cpp”中自动生成槽函数定义
6、在槽函数函数定义中添加要实现的功能实现关闭窗口的效果
自定义信号和槽
基本语法
在 Qt 中,允许自定义信号的发送方以及接收方,即可以自定义信号函数和槽函数。但是对于自定义的信号函数和槽函数有一定的书写规范。
1、自定义信号函数书写规范
(1) 自定义信号函数必须写到“signals"下;
(2) 返回值为 void,只需要声明,不需要实现;
(3) 可以有参数,也可以发生重载;
2、自定义槽函数书写规范
(1) 早期的 Qt 版本要求槽函数必须写到“public slots"下,但是现在高级版本的 Qt 允许写到类的”public”作用域中或者全局下;
(2) 返回值为 void,需要声明,也需要实现;
(3) 可以有参数,可以发生重载;
3、发送信号
使用"emit"关键字发送信号。"emit"是一个空的宏。"emit"其实是可选的,没有什么含义,只是为了提醒开发人员。
示例1:
1、在 widget.h 中声明自定义的信号和槽
#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
QT_BEGIN_NAMESPACE
namespace Ui {
class Widget;
}
QT_END_NAMESPACE
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(QWidget *parent = nullptr);
~Widget();
void EmitSignal(); //发送信号
signals:
void MySignal(); //信号声明
public slots:
void MySlots(); //槽声明
private:
Ui::Widget *ui;
};
#endif // WIDGET_H
2、在 widget.cpp 中实现槽函数,并且关联信号和槽
注意:顺序不能颠倒
原因是,首先关联信号和槽,一旦检测到信号发射之后就会立马执行关联的槽函数。反之,若先发射信号,此时还没有关联槽函数,当信号发射之后槽函数不会响应。
#include "widget.h"
#include "ui_widget.h"
#include <QPushButton>
#include <QDebug>
Widget::Widget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::Widget)
{
ui->setupUi(this);
//关联自定义的信号和槽
connect(this,&Widget::MySignal,this,&Widget::MySlots);
//发射信号
EmitSignal();
}
Widget::~Widget()
{
delete ui;
}
//编写函数实现信号的触发
void Widget::EmitSignal()
{
emit Widget::MySignal();
}
//自定义槽函数的实现
void Widget::MySlots()
{
qDebug() << "我的信号和槽";
}
示例2:当老师说 “上课了”,学生们就 “回到座位,开始学习”。
1、在源文件中新建两个类,一个是老师类,一个是学生类;首先选中项目名称,鼠标右键----->“add new…”
注意:
在 Qt 中新建类时,要选择新建类的父类。
显然,当前项目中还没啥类适合做新类的父类,同时新的类也不是一个“窗口”或者“控件”这种情况一般选择 QObject 作为基类。
这样做的好处是这个新类的对象可以搭配 Qt 的对象树机制便于对象的正确释放
添加完成之后,项目目录新增文件如下:
在 teacher.h 中声明信号函数:
// teacher.h
#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 中声明槽函数:
//student.h
#ifndef STUDENT_H
#define STUDENT_H
#include <QObject>
class Student : public QObject
{
Q_OBJECT
public:
explicit Student(QObject *parent = nullptr);
signals:
public slots:
void StartStudy(); //自定义槽函数声明
};
#endif // STUDENT_H
在 widget.h 中实例化"老师类对象”和“学生类对象";
//widget.h
#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
#include "teacher.h"
#include "student.h"
QT_BEGIN_NAMESPACE
namespace Ui {
class Widget;
}
QT_END_NAMESPACE
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(QWidget *parent = nullptr);
~Widget();
//发送信号
void EmitSignal();
private:
Teacher *tch; //发送信号的对象
Student *stu; //接受信号的对象
Ui::Widget *ui;
};
#endif // WIDGET_H
在 student.cpp 中实现槽函数:
//student.cpp
#include "student.h"
#include <QDebug>
Student::Student(QObject *parent)
: QObject{parent}
{
}
void Student::StartStudy()
{
qDebug() << "回到座位,开始学习";
}
在 widget.cpp 中连接⾃定义信号和槽:
//widget.cpp
#include "widget.h"
#include "ui_widget.h"
#include <QPushButton>
#include <QDebug>
Widget::Widget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::Widget)
{
ui->setupUi(this);
this->tch = new Teacher(this);
this->stu = new Student(this);
connect(tch,&Teacher::MySignal,stu,&Student::StartStudy);
EmitSignal(); //触发发送信号的函数
}
Widget::~Widget()
{
delete ui;
}
void Widget::EmitSignal()
{
emit tch->MySignal(); //发送信号
}
运行结果:
# 控制台终端显示
回到座位,开始学习
示例3:老师点击 “按钮” 触发学生上课
//widget.cpp
#include "widget.h"
#include "ui_widget.h"
#include <QPushButton>
#include <QDebug>
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);
resize(800,600);
btn->move(100,100);
connect(tch,&Teacher::MySignal,stu,&Student::StartStudy);
//MySignal接受到PushButton的信号就会触发上面的槽函数
connect(btn,&QPushButton::clicked,tch,&Teacher::MySignal);
EmitSignal(); //触发发送信号的函数
}
Widget::~Widget()
{
delete ui;
}
void Widget::EmitSignal()
{
emit tch->MySignal(); //发送信号
}
运行结果如下:
带参数的信号和槽
Qt 的信号和槽也支持带有参数,同时也可以支持重载。
此处我们要求,信号函数的参数列表要和对应连接的槽函数参数列表一致。
此时信号触发,调用到槽函数的时候,信号函数中的实参就能够被传递到槽函数的形参当中。
通过这样的机制, 就可以让信号给槽传递数据了
示例1:重载信号槽
(1) 在“widget.h"头文件中声明重载的信号函数以及重载的槽函数,如下图所示
//widget.h
#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
QT_BEGIN_NAMESPACE
namespace Ui {
class Widget;
}
QT_END_NAMESPACE
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(QWidget *parent = nullptr);
~Widget();
void EmitSignal();
signals:
void MySignal();
void MySignal(QString str);
public slots:
void MySlot();
void MySlot(QString str);
private:
Ui::Widget *ui;
};
#endif // WIDGET_H
(2) 在“ widget.cpp” 文件实现重载槽函数以及连接信号和槽。
//widget.cpp
#include "widget.h"
#include "ui_widget.h"
Widget::Widget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::Widget)
{
ui->setupUi(this);
// 显式无参数的信号和槽
connect(this, static_cast<void (Widget::*)()>(&Widget::MySignal),
this, static_cast<void (Widget::*)()>(&Widget::MySlot));
// 显式连接带有QString参数的信号和槽
connect(this, static_cast<void (Widget::*)(QString)>(&Widget::MySignal),
this, static_cast<void (Widget::*)(QString)>(&Widget::MySlot));
EmitSignal(); //发射信号
}
Widget::~Widget()
{
delete ui;
}
void Widget::EmitSignal()
{
emit MySignal();
emit MySignal("hello");
}
void Widget::MySlot()
{
qDebug() << "MySlot()被调用";
}
void Widget::MySlot(QString str)
{
qDebug() << "MySlot(QString str)被调用" << str;
}
(3) 执行结果如下图所示:
示例2:信号槽参数列表匹配规则
1、在 “widget.h” 头文件中声明信号和槽函数
// widget.h
#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
QT_BEGIN_NAMESPACE
namespace Ui {
class Widget;
}
QT_END_NAMESPACE
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(QWidget *parent = nullptr);
~Widget();
void EmitSignal();
signals:
void MySignal(QString str);
public slots:
void MySlot(QString str);
};
#endif // WIDGET_H
2、在 “widget.cpp” 文件中实现槽函数以及连接信号和槽
//widget.cpp
#include "widget.h"
#include "ui_widget.h"
#include <QDebug>
Widget::Widget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::Widget)
{
ui->setupUi(this);
connect(this,&Widget::MySignal,this,&Widget::MySlot);
EmitSiganl();
}
Widget::~Widget()
{
delete ui;
}
void Widget::EmitSiganl()
{
QString str = "Hello";
emit Widget::MySignal(str);
}
void Widget::MySlot(QString str)
{
qDebug() << str;
}
其实信号的参数个数可以多于槽函数的参数个数,但是槽的参数个数不能多于信号参数个数
但是实际开发中最好还是保持参数个数也能匹配一致.
示例3:
1、在 “widget.h” 头文件中声明信号和槽函数;
//widget.h
#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
#include <QString>
QT_BEGIN_NAMESPACE
namespace Ui {
class Widget;
}
QT_END_NAMESPACE
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(QWidget *parent = nullptr);
~Widget();
void EmitSiganl(); //信号发射函数
signals:
void MySignal(QString str); //信号函数有一个参数
public slots:
void MySlot(); //槽函数无参数
private:
Ui::Widget *ui;
};
#endif // WIDGET_H
2、在 “widget.cpp” 文件中实现槽函数以及连接信号和槽;
//widget.cpp
#include "widget.h"
#include "ui_widget.h"
#include <QDebug>
Widget::Widget(QWidget *parent)
: QWidget(parent)
, ui(new Ui::Widget)
{
ui->setupUi(this);
connect(this,&Widget::MySignal,this,&Widget::MySlot);
EmitSiganl();
}
Widget::~Widget()
{
delete ui;
}
void Widget::EmitSiganl()
{
QString str = "Hello";
emit Widget::MySignal(str);
}
void Widget::MySlot()
{
qDebug() << "Hello World";
}
信号与槽的连接方式
一对一
主要有两种形式,分别是:一个信号连接一个槽和一个信号连接一个信号。
(1) 一个信号连接一个槽
示例:
1、在 “widget.h” 中声明信号和槽以及信号发射函数
//widget.h
#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(); //信号函数声明
public slots:
void MySlots(); //槽函数声明
};
#endif // WIDGET_H
2、在 “widget.cpp” 中实现槽函数,信号发射函数以及连接信号和槽
//widget.cpp
#include "widget.h"
#include <QDebug>
Widget::Widget(QWidget *parent)
: QWidget(parent)
{
connect(this,&Widget::MySignal,this,&Widget::MySlots);
EmitSignal(); //发射信号函数
}
Widget::~Widget() {}
void Widget::EmitSignal()
{
emit MySignal();
}
void Widget::MySlots()
{
qDebug() << "好好学习,天天向上";
}
(2) 一个信号连接另一个信号
示例:
在上述示例的基础上,在 “widget.cpp” 文件中添加如下代码
//widget.cpp
#include "widget.h"
#include <QDebug>
#include <QPushButton>
Widget::Widget(QWidget *parent)
: QWidget(parent)
{
QPushButton *btn = new QPushButton("按钮",this);
resize(800,600);
btn->move(250,250);
connect(this,&Widget::MySignal,this,&Widget::MySlots);
//信号与信号连接
connect(btn,&QPushButton::clicked,this,&Widget::MySignal);
EmitSignal(); //发射信号函数
}
Widget::~Widget() {}
void Widget::EmitSignal()
{
emit MySignal();
}
void Widget::MySlots()
{
qDebug() << "好好学习,天天向上";
}
一对多
一个信号连接多个槽
示例:
(1) 在 “widget.h” 头文件中声明一个信号和三个槽;
//widget.h
#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(); //信号函数声明
public slots:
void MySlots1(); //槽函数1声明
void MySlots2(); //槽函数2声明
void MySlots3(); //槽函数3声明
};
#endif // WIDGET_H
(2) 在 “widget.cpp” 文件中实现槽函数以及连接信号和槽
//widget.cpp
#include "widget.h"
#include <QDebug>
#include <QPushButton>
Widget::Widget(QWidget *parent)
: QWidget(parent)
{
connect(this,&Widget::MySignal,this,&Widget::MySlots1);
connect(this,&Widget::MySignal,this,&Widget::MySlots2);
connect(this,&Widget::MySignal,this,&Widget::MySlots3);
EmitSignal(); //发射信号函数
}
Widget::~Widget() {}
void Widget::EmitSignal()
{
emit MySignal();
}
void Widget::MySlots1()
{
qDebug() << "MySlots1";
}
void Widget::MySlots2()
{
qDebug() << "MySlots2";
}
void Widget::MySlots3()
{
qDebug() << "MySlots3";
}
多对一
多个信号连接一个槽函数
示例:
(1) 在 “widget.h” 头文件中声明两个信号以及一个槽
//widget.h
#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_1(); //信号函数1声明
void MySignal_2(); //信号函数2声明
void MySignal_3(); //信号函数3声明
public slots:
void MySlots(); //槽函数声明
};
#endif // WIDGET_H
(2) 在 “widget.cpp” 文件中实现槽函数以及连接信号和槽
//widget.cpp
#include "widget.h"
#include <QDebug>
#include <QPushButton>
Widget::Widget(QWidget *parent)
: QWidget(parent)
{
QPushButton *btn = new QPushButton("按钮",this);
btn->move(100,100);
resize(800,600);
connect(this,&Widget::MySignal_1,this,&Widget::MySlots); //MySignal_1 信号连接槽
connect(this,&Widget::MySignal_2,this,&Widget::MySlots); //MySignal_2 信号连接槽
connect(btn,&QPushButton::clicked,this,&Widget::MySlots); //按钮信号 连接 槽
EmitSignal(); //发射信号函数
}
Widget::~Widget() {}
void Widget::EmitSignal()
{
emit MySignal_1();
emit MySignal_2();
}
void Widget::MySlots()
{
qDebug() << "MySlot";
}
信号和槽的其他说明
信号与槽的断开
使用 disconnect 即可完成断开
disconnect 的用法和 connect 基本一致
示例:
Qt4 版本信号与槽的连接
Qt4 中的 connect 用法和 Qt5 相比是更复杂的。需要搭配 SIGNAL
和 SLOT
宏来完成
而且缺少必要的函数类型的检查,使代码更容易出错
示例:
(1) 在 “widget.h” 头文件中声明信号和槽
(2) 在 “widget.cpp” 文件中实现槽函数以及连接信号与槽;
Qt4 版本信号与槽连接的优缺点:
- 优点:参数直观;
- 缺点:参数类型不做检测;
示例:
信号与槽的优缺点
优点:松散耦合
信号发送者不需要知道发出的信号被哪个对象的槽函数接收,槽函数也不需要知道哪些信号关联了自己,Qt 的信号槽机制保证了信号与槽函数的调用。支持信号槽机制的类或者父类必须继承于 QObject
缺点: 效率较低
与回调函数相比,信号和槽稍微慢一些,因为它们提供了更高的灵活性,尽管在实际应用程序中差别不大。通过信号调用的槽函数比直接调用的速度慢约10倍(这是定位信号的接收对象所需的开销,遍历所有关联,编组/解组传递的参数,多线程时,信号可能需要排队》,这种调用速度对性能要求不是非常高的场景是可以忽略的,是可以满足绝大部分场景。
一个客户端程序中,最慢的环节往往是“人"。
假设本身基于回调的方式是 10us,使用信号槽的方式是 100us。对于使用程序的人来说,是感知不到的。