Qt信号与槽的使用

参考视频：黑马程序员https://www.bilibili.com/video/BV1XW411x7NU?p=4

1  新建工程

先创建一个控件基础工程，创建后的界面如下：

主函数我们不需要修改，就保持这样，对于C++的知识我不太理解。

上述代码中，执行到第7行的时候，会先去执行基类的构造函数，再执行MyWidget类的构造函数。我们只需要在构造函数中实现需要实现的功能。

构造函数对应在mywidget.cpp中：

2  测试代码

实例一：标准的信号处理

测试目的：在主窗口中，新建两个按钮，功能如下：

按钮一的功能：按下按钮，关闭主窗口；

按钮二的功能：释放按钮，更改按钮二的文本，并隐藏按钮一。

由于在实现过程中，会用到信号与槽的知识，就先简单介绍一下基本知识，可能不正确，这只是我个人的理解：

信号：某一事件发生时产生，用于表示一个事件发生了。

槽：就是信号处理函数，用于指示当信号发生时，需要做出什么动作。

其中，我们connect函数来连接信号与槽之间的关系，函数的原型如下：

connect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type = Qt::AutoConnection);

举例说明：

connect(&b1, &QPushButton::pressed, this, &MyWidget::close);

/* &b1：信号发出者，指针类型

* &QPushButton::pressed：处理的信号，&发送者的类名::信号名字

* this：信号接收者

* &MyWidget::close：槽函数，信号处理函数 &接收的类名::槽函数名字

*/

不同的控件有哪些信号，可通过帮助文档查看，以QPushButton为例进行说明（点QPushButton，再按F1）：

这里没有看到signal函数，可能是从它的父类继承过来的，我们再看一下它的父类：

 实现的相关代码

 先在MyWidget类中实现两个按钮（mywidget.h）：

#ifndef MYWIDGET_H
#define MYWIDGET_H

#include <QWidget>
#include <QPushButton>

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget(QWidget *parent = 0);
    ~MyWidget();

private:
    QPushButton b1;
    QPushButton *b2;

    void myslot();

};

#endif // MYWIDGET_H

再在构造函数中实现两个按钮的功能（mywidget.cpp）：

#include "mywidget.h"
#include <QPushButton>

MyWidget::MyWidget(QWidget *parent)
    : QWidget(parent)
{
    b1.setParent(this);
    b1.setText("按钮一");
    b1.move(100, 100);

    b2 = new QPushButton(this);
    b2->setText("按钮二");

    connect(&b1, &QPushButton::pressed, this, &MyWidget::close);
    /* &b1：信号发出者，指针类型
    *  &QPushButton::pressed：处理的信号，&发送者的类名::信号名字
    *  this：信号接收者
    *  &MyWidget::close：槽函数，信号处理函数 &接收的类名::槽函数名字
    */

    /*
     * 自定义槽，普通函数的用法
     * Qt5：任意的成员函数，普通全局函数，静态函数
     * 槽函数需要和信号一致（参数、返回值）
     * 由于信号都是没有返回值，所以槽函数一定没有返回值
     */
     connect(b2, &QPushButton::released, this, &MyWidget::myslot);

     connect(b2, &QPushButton::released, &b1, &MyWidget::hide);
    /*
     * 信号：短信
     * 槽函数：接收短信的手机
    */
}

void MyWidget::myslot()
{
    b2->setText("123");
}

MyWidget::~MyWidget()
{

}

运行，进行测试：

 实例二：自定义不带参数信号处理

目的：实现两个窗口，主窗口和子窗口，并且每个窗口都有一个按键，按键功能如下：

主窗口按键的功能：显示子窗口，关闭父窗口；

子窗口按键的功能：关闭子窗口，显示父窗口。

主窗口和子窗口的切换显示全部由主窗口控制，可以理解为：主窗口的权限大于子窗口，子窗口的按键按下去只是产生一个信号，主窗口再对信号进行处理。

新建一个工程，工程创建之后，有以下文件，其中，subwindown相关文件是通过点击signal_slot_2目录文件，选择添加新文件，选择C++ --> C++ Class，基类我们选择QWidget：

 实现的代码如下：

widget.h是widget类所在同文件，主要实现：声明主窗口按键处理函数、声明子窗口信号接收处理函数、实例化一个subwindown类对象、实例化一个QPushButton类对象。

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QPushButton>
#include "subwindown.h"

class Widget : public QWidget
{
    Q_OBJECT

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

    void my_slot();
    void dealsub();

private:
    QPushButton b_main;

    subwindown sw;
};

#endif // WIDGET_H

subwindown.h是subwindown类所在头文件，主要实现：声明子窗口按键处理函数、声明一个信号、实例化一个QPushButton类对象。

#ifndef SUBWINDOWN_H
#define SUBWINDOWN_H

#include <QWidget>
#include <QPushButton>

class subwindown : public QWidget
{
    Q_OBJECT
public:
    explicit subwindown(QWidget *parent = nullptr);
    //定义槽函数
    void sendslot();

signals:
    /*
    * 信号必须有signals关键字声明
    * 信号没有返回值，但可以有参数
    * 信号就是函数的声明，只需声明，无需定义
    * 使用：emit mysignal();
    */
    void mysignal();

public slots:

private:
    QPushButton b_sub;

};

#endif // SUBWINDOWN_H

main.cpp中的代码不改动，就使用生成的代码：

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

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.show();

    return a.exec();
}

widget.cpp中实现的是主窗口的构造函数，主要实现：接收主窗口按键的信号并处理、接收子窗口发送的信号并处理。

#include "widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    setWindowTitle("主窗口");

    //设置按钮相关属性
    b_main.setParent(this);
    b_main.setText("切换子窗口");
    b_main.move(50, 50);
    //处理主窗口的按钮所产生的信号
    connect(&b_main, &QPushButton::clicked, this, Widget::my_slot);

    //接收子窗口信号，并进行处理
    connect(&sw, &subwindown::mysignal, this, &Widget::dealsub);
    resize(400, 300);
}

void Widget::my_slot()
{
    //显示子窗口
    sw.show();
    //父窗口隐藏
    this->hide();
}

void Widget::dealsub()
{
    //主窗口显示
    this->show();
    //子窗口隐藏
    sw.hide();
}

Widget::~Widget()
{

}

subwindown.cpp中实现的是子窗口的构造函数，主要实现：接收子进程按键的信号并处理，处理方式为发送一个自定义信号。

#include "subwindown.h"

subwindown::subwindown(QWidget *parent) : QWidget(parent)
{
    setWindowTitle("子窗口");

    //按键属性设置
    b_sub.setText("切换主窗口");
    b_sub.setParent(this);
    b_sub.move(50, 50);

    //接收按键信号并处理
    connect(&b_sub, &QPushButton::clicked, this, &subwindown::sendslot);
    resize(400, 300);
}

void subwindown::sendslot()
{
    //发送信号
    emit mysignal();
}

运行测试：

点击“切换子窗口”按键：

实例三：自定义带参数信号处理

功能：在空白窗口中定义一个按钮，点击按钮发送一个自定义的带参数的信号，然后由本窗口接收信号并将参数打印出来。

首先，创建一个控件基类工程，创建后包含的文件如下：

在widget.h中，实现的功能有：声明一个发送信号函数、声明一个接收信号函数、自定义一个带参数的信号、实例化一个QPushButton对象。

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QPushButton>

class Widget : public QWidget
{
    Q_OBJECT

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

    //点击按钮，发送信号函数
    void send_signal();
    //接收信号处理函数
    void recv_signal(int, QString);

signals:
    //自定义一个带参数的信号
    void mysignal(int, QString);

private:
    QPushButton b_main;

};

#endif // WIDGET_H

在widget.cpp中，实现的功能有：接收点击按键的信号并进行处理，接收自定义的信号并进行处理。

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

Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    b_main.setParent(this);
    b_main.setText("发送");
    b_main.move(100, 100);

    //点击按钮，发送信号
    connect(&b_main, &QPushButton::clicked, this, &Widget::send_signal);

    //接收点击按钮，发送的信号
    void (Widget::*testsignal)(int, QString) = &Widget::mysignal;
    connect(this, testsignal, this, &Widget::recv_signal);

    this->resize(300, 300);
}

void Widget::send_signal()
{
    emit mysignal(100, "我已经发送信号");
}

void Widget::recv_signal(int a, QString str)
{
    qDebug() << a << str;
}

Widget::~Widget()
{

}

运行，并进行测试，点击一次发送按钮，就会发送一个自定义信号，并接收到了它：

实例四：lambda表达式的使用 

功能：创建一个按钮，点击按钮发送一个信号，不需要指定信号接收函数和信号接收者，直接使用匿名函数（lambda表达式）实现。

先新建一个工程，新建后的工程文件如下：

由于lambda是C++11支持的特性，所以我们需要在lambda_test.pro文件末尾添加一句：CONFIG += C++11

先把代码放上，再说明lambda表达式的作用。

widget.h文件：

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QPushButton>

class Widget : public QWidget
{
    Q_OBJECT

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

private:
    //定义一个类中成员变量
    int a = 10;

};

#endif // WIDGET_H

widget.cpp文件：

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

Widget::Widget(QWidget *parent)
    : QWidget(parent)
{
    QPushButton *b_main = new QPushButton(this);
    b_main->setParent(this);
    b_main->setText("开始");
    b_main->move(100, 100);

    //定义一个外部局部变量
    int b = 12;
    //Lambda表达式，匿名函数对象
    //C++11增加的新特性，项目文件： CONFIG += C++11
    //Qt配合信号一起使用，非常方便
    connect(b_main, &QPushButton::clicked,
        // =：把外部所有局部变量、类中所有成员以值方式传进来
        // this：类中所有成员以值传递方式
        // &：引用符号，外部所有局部变量
        [=](bool isCheck)mutable
        {
            b_main->setText("lambda表达式");
            qDebug() << "已经进入lambda表达式";
            qDebug() << a << b;
            a += 10;
            b += 20;
            qDebug() << isCheck;
        }
    );

    this->resize(300, 300);
}

Widget::~Widget()
{

}

下面就简单的说明lambda表达式的语法，我也不是很懂，根据测试结果进行说明。

参考了这篇博客：https://www.cnblogs.com/rainbow70626/p/10328143.html

格式：[capture](parameters) mutable ->return-type{statement};

capture：捕捉列表，也单独代表函数的开始，主要有以下使用方式：

• 单独传递外部变量，如：[b_main]
• =：把外部所有局部变量、类中所有成员以值方式传进来（widget.c和widget.h文件中的成员）
• this：类中所有成员以值传递方式（widget.h文件中的成员）
• &：引用符号，外部所有局部变量（widget.c文件中的成员），当变量是指针时，最好别用这个。

parameters：参数列表，信号的参数。

mutable ：值传递时，默认变量为只读的，如果需要在匿名函数中改变它，需要这个参数

运行代码进行测试：