C++框架_之Qt的信号和槽的详解

C++_之Qt的信号和槽的详解

1、概述

　　信号槽是 Qt 框架引以为豪的机制之一。所谓信号槽，实际就是观察者模式。当某个事件发生之后，比如，按钮检测到自己被点击了一下，它就会发出一个信号（signal）。这种发出是没有目的的，类似广播。如果有对象对这个信号感兴趣，它就会使用连接（connect）函数，意思是，将想要处理的信号和自己的一个函数（称为槽（slot））绑定来处理这个信号。也就是说，当信号发出时，被连接的槽函数会自动被回调。这就类似观察者模式：当发生了感兴趣的事件，某一个操作就会被自动触发。（这里提一句，Qt 的信号槽使用了额外的处理来实现，并不是 GoF 经典的观察者模式的实现方式。）

　　信号和槽是Qt特有的信息传输机制，是Qt设计程序的重要基础，它可以让互不干扰的对象建立一种联系。

　　槽的本质是类的成员函数，其参数可以是任意类型的。和普通C++成员函数几乎没有区别，它可以是虚函数；也可以被重载；可以是公有的、保护的、私有的、也可以被其他C++成员函数调用。唯一区别的是：槽可以与信号连接在一起，每当和槽连接的信号被发射的时候，就会调用这个槽。

1.1对象树

参考连接：https://blog.csdn.net/fzu_dianzi/article/details/6949081

Qt提供了一种机制，能够自动、有效的组织和管理继承自QObject的Qt对象，这种机制就是对象树。

Qt对象树在用户界面编程上是非常有用的。它能够帮助程序员减轻内存泄露的压力。

比如说当应用程序创建了一个具有父窗口部件的对象时，该对象将被加入父窗口部件的孩子列表。当应用程序销毁父窗口部件时，其下的孩子列表中的对象将被一一删除。这让我们在编程时，能够将主要精力放在系统的业务上，提高编程效率，同时也保证了系统的稳健性。

下面笔者将简单分析对象树。

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QDialog *dlg = );
    QPushButton *btn = new QPushButton(dlg);
    qDebug() << "dlg = " << dlg;
    qDebug() << "btn = " << btn;
    dlg->exec();
    delete btn;
    qDebug() << "dlg = " << dlg;
    ;
}
dlg = QDialog(0x3ea1a0)
btn = QPushButton(0x3ea228)
/*关闭窗口后，dlg = QDialog(0x3ea1a0)
这说明关闭窗口，不会销毁该窗口部件，而是将其隐藏起来。
我们在qDebug() << "dlg = " << dlg;
之后加上
qDebug() << "btn = " << btn;
明显的，我们之前已经delete btn，btn指针没有被赋值为0，这是编译器决定的。
执行程序后，必然出现段错误。
2、
将程序稍微修改下。*/
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QDialog *dlg = );
    QPushButton *btn = new QPushButton(dlg);
    qDebug() << "dlg = " << dlg;
    qDebug() << "btn = " << btn;
    dlg->exec();
    delete dlg;
    qDebug() << "btn = " << btn;
    ;
}

2、信号和槽

为了体验一下信号槽的使用，我们以一段简单的代码说明：

Qt5 的书写方式：（推荐的使用）★★★★★

#include <QApplication>
#include <QPushButton>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    QPushButton button("Quit");
QObject::connect(&button, &QPushButton::clicked,
&app, &QApplication::quit);
    button.show();
    return app.exec();
}

我们按照前面文章中介绍的在 Qt Creator 中创建工程的方法创建好工程，然后将main()函数修改为上面的代码。点击运行，我们会看到一个按钮，上面有“Quit”字样。点击按钮，程序退出。

connect()函数最常用的一般形式：

connect(sender, signal, receiver, slot);

参数：

sender：发出信号的对象

signal：发送对象发出的信号

receiver：接收信号的对象

slot：接收对象在接收到信号之后所需要调用的函数

信号槽要求信号和槽的参数一致，所谓一致，是参数类型一致。如果不一致，允许的情况是，槽函数的参数可以比信号的少，即便如此，槽函数存在的那些参数的顺序也必须和信号的前面几个一致起来。这是因为，你可以在槽函数中选择忽略信号传来的数据（也就是槽函数的参数比信号的少），但是不能说信号根本没有这个数据，你就要在槽函数中使用（就是槽函数的参数比信号的多，这是不允许的）。

如果信号槽不符合，或者根本找不到这个信号或者槽函数，比如我们改成：

connect(&button, &QPushButton::clicked, &QApplication::quit2);

由于 QApplication 没有 quit2 这样的函数，因此在编译时会有编译错误：

'quit2' is not a member of QApplication

这样，使用成员函数指针我们就不会担心在编写信号槽的时候出现函数错误。

Qt4 的书写方式：

int main(int argc, char *argv[])
{
        QApplication a(argc, argv);
        QPushButton *button = new QPushButton("Quit");
        connect(button, SIGNAL(clicked()), &a, SLOT(quit()));
        button->show();
        return a.exec();
}

这里使用了SIGNAL和SLOT这两个宏，将两个函数名转换成了字符串。注意到connect()函数的 signal 和 slot 都是接受字符串，一旦出现连接不成功的情况，Qt4是没有编译错误的（因为一切都是字符串，编译期是不检查字符串是否匹配），而是在运行时给出错误。这无疑会增加程序的不稳定性。

Qt5在语法上完全兼容Qt4

小总结：　

　　1>. 格式: connect(信号发出者对象(指针), &className::clicked, 信号接收者对象(指针), &classB::slot);
　　2>. 标准信号槽的使用:
　　　　connect(sender, &Send::signal, receiver, &Receiver::slot)

3、自定义信号槽

使用connect()可以让我们连接系统提供的信号和槽。但是，Qt 的信号槽机制并不仅仅是使用系统提供的那部分，还会允许我们自己设计自己的信号和槽。

下面我们看看使用 Qt 的信号槽，实现一个报纸和订阅者的例子：

有一个报纸类Newspaper，有一个订阅者类Subscriber。Subscriber可以订阅Newspaper。这样，当Newspaper有了新的内容的时候，Subscriber可以立即得到通知。

#include <QObject>
 ////////// newspaper.h //////////
class Newspaper : public QObject
{
    Q_OBJECT
public:
    Newspaper(const QString & name) :
        m_name(name)
    {
    }

    void send()
    {
        emit newPaper(m_name);
    }

signals:
    void newPaper(const QString &name);

private:
    QString m_name;
};

////////// reader.h //////////
#include <QObject>
#include <QDebug>

class Reader : public QObject
{
    Q_OBJECT
public:
    Reader() {}

    void receiveNewspaper(const QString & name)
    {
        qDebug() << "Receives Newspaper: " << name;
    }
};

////////// main.cpp //////////
#include <QCoreApplication>

#include "newspaper.h"
#include "reader.h"

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

    Newspaper newspaper("Newspaper A");
    Reader reader;
    QObject::connect(&newspaper, &Newspaper::newPaper,
                     &reader,    &Reader::receiveNewspaper);
    newspaper.send();

    return app.exec();
}

●首先看Newspaper这个类。这个类继承了QObject类。只有继承了QObject类的类，才具有信号槽的能力。所以，为了使用信号槽，必须继承QObject。凡是QObject类（不管是直接子类还是间接子类），都应该在第一行代码写上Q_OBJECT。不管是不是使用信号槽，都应该添加这个宏。这个宏的展开将为我们的类提供信号槽机制、国际化机制以及 Qt 提供的不基于 C++ RTTI 的反射能力。

● Newspaper类的 public 和 private 代码块都比较简单，只不过它新加了一个 signals。signals 块所列出的，就是该类的信号。信号就是一个个的函数名，返回值是 void（因为无法获得信号的返回值，所以也就无需返回任何值），参数是该类需要让外界知道的数据。信号作为函数名，不需要在 cpp 函数中添加任何实现。

●Newspaper类的send()函数比较简单，只有一个语句emit newPaper(m_name);。emit 是 Qt 对 C++ 的扩展，是一个关键字（其实也是一个宏）。emit 的含义是发出，也就是发出newPaper()信号。感兴趣的接收者会关注这个信号，可能还需要知道是哪份报纸发出的信号？所以，我们将实际的报纸名字m_name当做参数传给这个信号。当接收者连接这个信号时，就可以通过槽函数获得实际值。这样就完成了数据从发出者到接收者的一个转移。

● Reader类更简单。因为这个类需要接受信号，所以我们将其继承了QObject，并且添加了Q_OBJECT宏。后面则是默认构造函数和一个普通的成员函数。Qt 5 中，任何成员函数、static 函数、全局函数和 Lambda 表达式都可以作为槽函数。与信号函数不同，槽函数必须自己完成实现代码。槽函数就是普通的成员函数，因此作为成员函数，也会受到 public、private 等访问控制符的影响。（如果信号是 private 的，这个信号就不能在类的外面连接，也就没有任何意义。）

3.1自定义信号槽需要注意的事项

●发送者和接收者都需要是QObject的子类（当然，槽函数是全局函数、Lambda 表达式等无需接收者的时候除外）；

●使用 signals 标记信号函数，信号是一个函数声明，返回 void，不需要实现函数代码；

●槽函数是普通的成员函数，作为成员函数，会受到 public、private、protected 的影响；

●使用 emit 在恰当的位置发送信号；

●使用QObject::connect()函数连接信号和槽。

●任何成员函数、static 函数、全局函数和 Lambda 表达式都可以作为槽函数

3.2信号槽的更多用法

● 一个信号可以和多个槽相连

　　如果是这种情况，这些槽会一个接一个的被调用，但是它们的调用顺序是不确定的。

●多个信号可以连接到一个槽

　　只要任意一个信号发出，这个槽就会被调用。

●一个信号可以连接到另外的一个信号

　　当第一个信号发出时，第二个信号被发出。除此之外，这种信号-信号的形式和信号-槽的形式没有什么区别。

●槽可以被取消链接

　　这种情况并不经常出现，因为当一个对象delete之后，Qt自动取消所有连接到这个对象上面的槽。

●使用Lambda 表达式

　　在使用 Qt 5 的时候，能够支持 Qt 5 的编译器都是支持 Lambda 表达式的。

　　我们的代码可以写成下面这样：

QObject::connect(&newspaper, static_cast<void (Newspaper:: *)
(const QString &)>(&Newspaper::newPaper),
[=](const QString &name)
{ /* Your code here. */ }
);

在连接信号和槽的时候，槽函数可以使用Lambda表达式的方式进行处理。

4、Lambda表达式

C++11中的Lambda表达式用于定义并创建匿名的函数对象，以简化编程工作。首先看一下Lambda表达式的基本构成：

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　[函数对象参数](操作符重载函数参数)mutable或exception ->返回值{函数体}

①函数对象参数；

　　[]，标识一个Lambda的开始，这部分必须存在，不能省略。函数对象参数是传递给编译器自动生成的函数对象类的构造函数的。函数对象参数只能使用那些到定义Lambda为止时Lambda所在作用范围内可见的局部变量（包括Lambda所在类的this）。函数对象参数有以下形式：

　　　　 ▲空。没有使用任何函数对象参数。

　　　　 ▲=。函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是值传递方式（相当于编译器自动为我们按值传递了所有局部变量）。

　　　　 ▲&。函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是引用传递方式（相当于编译器自动为我们按引用传递了所有局部变量）。

　　　　 ▲ this。函数体内可以使用Lambda所在类中的成员变量。

　　　　 ▲ a。将a按值进行传递。按值进行传递时，函数体内不能修改传递进来的a的拷贝，因为默认情况下函数是const的。要修改传递进来的a的拷贝，可以添加mutable修饰符。

　　　　 ▲ &a。将a按引用进行传递。

　　　    ▲ a, &b。将a按值进行传递，b按引用进行传递。

　　　　 ▲ =，&a, &b。除a和b按引用进行传递外，其他参数都按值进行传递。

　　　　 ▲ &, a, b。除a和b按值进行传递外，其他参数都按引用进行传递。

, n = ;
[=] ();
      [&] ();

      [=,&m] ();
      [&,m] ();

      [m,n] ();
      [&m,&n] ();

② 操作符重载函数参数；

标识重载的()操作符的参数，没有参数时，这部分可以省略。参数可以通过按值（如：(a,b)）和按引用（如：(&a,&b)）两种方式进行传递。

③ 可修改标示符；

mutable声明，这部分可以省略。按值传递函数对象参数时，加上mutable修饰符后，可以修改按值传递进来的拷贝（注意是能修改拷贝，而不是值本身）。

④ 错误抛出标示符；

exception声明，这部分也可以省略。exception声明用于指定函数抛出的异常，如抛出整数类型的异常，可以使用throw(int)

⑤ 函数返回值；

->返回值类型，标识函数返回值的类型，当返回值为void，或者函数体中只有一处return的地方（此时编译器可以自动推断出返回值类型）时，这部分可以省略。

⑥ 是函数体；

{}，标识函数的实现，这部分不能省略，但函数体可以为空。

总结：

案例代码：

mainwidget.h

#ifndef MAINWIDGET_H
#define MAINWIDGET_H

#include <QWidget>
#include <QPushButton>
#include "subwidget.h" //子窗口头文件

class MainWidget : public QWidget
{
    Q_OBJECT

public:
    MainWidget(QWidget *parent = );
    ~MainWidget();

public slots:
    void mySlot();
    void changeWin();
    void dealSub();
    void dealSlot(int, QString);

private:
    QPushButton b1;
    QPushButton *b2;
    QPushButton b3;

    SubWidget subWin;
};

#endif // MAINWIDGET_H

subwidget.h

#ifndef SUBWIDGET_H
#define SUBWIDGET_H

#include <QWidget>
#include <QPushButton>

class SubWidget : public QWidget
{
    Q_OBJECT
public:
    );

    void sendSlot();

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

    void mySignal();
    void mySignal(int, QString);

public slots:

private:
    QPushButton b;
};

#endif // SUBWIDGET_H

main.cpp

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

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWidget w;//执行MainWidget的构造函数
    w.show();

    return a.exec();
}

mainwidget.cpp

#include "mainwidget.h"
#include <QPushButton>
#include <QDebug> //打印

MainWidget::MainWidget(QWidget *parent)
    : QWidget(parent)
{
    b1.setParent(this);
    b1.setText("close");
    b1.move(, );

    b2 = new QPushButton(this);
    b2->setText("abc");

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

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

    connect(b2, &QPushButton::released, &b1, &QPushButton::hide);

    /* 信号：短信
     * 槽函数：接收短信的手机
     */

    setWindowTitle("老大");
    //this->setWindowTitle("老大");//等价同上

    b3.setParent(this);
    b3.setText("切换到子窗口");
    b3.move(, );

    //显示子窗口
    //subWin.show();

    connect(&b3, &QPushButton::released, this, &MainWidget::changeWin);

    //处理子窗口的信号
//    void (SubWidget::*funSignal)() = &SubWidget::mySignal;
//    connect(&subWin, funSignal, this, &MainWidget::dealSub);

//     void (SubWidget::*testSignal)(int, QString) = &SubWidget::mySignal;
//    connect(&subWin, testSignal, this, &MainWidget::dealSlot);

    //Qt4信号连接
    //Qt4槽函数必须有slots关键字来修饰
    connect(&subWin, SIGNAL(mySignal()), this, SLOT(dealSub()) );

    connect(&subWin, SIGNAL(mySignal(int,QString)),
            this, SLOT(dealSlot(int,QString)) );
    //缺点： SIGNAL SLOT 将函数名字 -> 字符串  不进行错误检查

    //Lambda表达式, 匿名函数对象
    //C++11增加的新特性， 项目文件： CONFIG += C++11
    //Qt配合信号一起使用，非常方便

    QPushButton *b4 = new QPushButton(this);
    b4->setText("Lambda表达式");
    b4->move(, );
    , b = ;
    connect(b4, &QPushButton::clicked,
            // = :把外部所有局部变量、类中所有成员以值传递方式
            // this: 类中所有成员以值传递方式
            // & : 把外部所有局部变量， 引用符号
            [=](bool isCheck)
            {
                qDebug() << isCheck;
            }

            );

    resize(, );
}

void MainWidget::dealSlot(int a, QString str)
{
    // str.toUtf8() -> 字节数组QByteArray
    // ……data()  -> QByteArray -> char *
    qDebug() << a << str.toUtf8().data();
}

void MainWidget::mySlot()
{
    b2->setText(");
}

void MainWidget::changeWin()
{
    //子窗口显示
    subWin.show();
    //本窗口隐藏
    this->hide();
}

void MainWidget::dealSub()
{
    //子窗口隐藏
    subWin.hide();
    //本窗口显示
    show();
}

MainWidget::~MainWidget()
{

}

subwidget.cpp

#include "subwidget.h"

SubWidget::SubWidget(QWidget *parent) : QWidget(parent)
{
    this->setWindowTitle("小弟");
    b.setParent(this);
    b.setText("切换到主窗口");

    connect(&b, &QPushButton::clicked, this, &SubWidget::sendSlot);

    resize(, );
}

void SubWidget::sendSlot()
{
    emit mySignal();
    emit mySignal(, "我是子窗口");
}

SingnalAndSlot.pro

QT       += core gui

greaterThan(QT_MAJOR_VERSION, ): QT += widgets

TARGET = 03_SignalAndSlot
TEMPLATE = app

SOURCES += main.cpp\
        mainwidget.cpp \
    subwidget.cpp

HEADERS  += mainwidget.h \
    subwidget.h

CONFIG += C++

以上资料来源于互联网和自己的见解。如有雷同，不胜荣幸。