2019 September 18 CPP基础

QT-第二节 QT中的信号和槽机制

QT中的信号和槽机制

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

系统自带的信号和槽

  1. 实现一个功能，点击按钮，关闭当前窗口

     MYButton *mybtn = new MYButton;
 mybtn->move(200,200);
 mybtn->setParent(this);
 connect(mybtn,&MYButton::clicked,this,&MyWidget::close);
  2. connect()函数最常用的一般形式：
    1. connect(sender, signal, receiver, slot);
    2. 参数解释:
      1. sender：发出信号的对象
      2. signal：发送对象发出的信号
      3. receiver：接收信号的对象
      4. slot：接收对象在接收到信号之后所需要调用的函数（槽函数）

  3. 那么系统自带的信号和槽通常如何查找呢，这个就需要利用帮助文档了，在帮助文档中比如我们上面的按钮的点击信号，在帮助文档中输入QPushButton，首先我们可以在Contents中寻找关键字 signals，信号的意思，但是我们发现并没有找到，这时候我们应该想到也许这个信号的被父类继承下来的，因此我们去他的父类QAbstractButton中就可以找到该关键字，点击signals索引到系统自带的信号有如下几个

     void  clicked(bool checked = false) //点击模式
 void  pressed() //按下
 void  released() //松开
 void  toggled(bool checked) //开关模式

自定义信号和槽

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

    1. MyWidget类

       #ifndef MYWIDGET_H
 #define MYWIDGET_H
        
 #include <QWidget>
 #include"teacher.h"
 #include"student.h"
 class MyWidget : public QWidget
 {
     Q_OBJECT
        
 public:
     MyWidget(QWidget *parent = nullptr);
     ~MyWidget();
        
     //成员变量
     Teacher *te;
     Student *st;
     void classIsOver();
 };
 #endif // MYWIDGET_H
        
 //
 #include "mywidget.h"
 #include"student.h"
 #include"teacher.h"
 #include<QPushButton>
 /*
  *创建两个类：老师、学生
  * 老师发出信号：饿了
  * 学生接收信号并作出处理:请客吃饭
 */
        
 MyWidget::MyWidget(QWidget *parent)
     : QWidget(parent)
 {
     //1. 创建老师学生
     //指定parent，不需要管理内存了
    te = new Teacher(this);
    st = new Student(this);
        
        
    //2. 连接老师、学生
    //无参,如果信号和槽没有被重载，那么这么写没事，但是如果有重载这么写就有二义性了
     //   connect(te,&Teacher::hungry,st,&Student::treat);
    //但是由于有两个重名的自定义信号和自定义的槽，直接连接会报错，所以需要利用函数指针来指向函数地址， 然后在做连接
    //无参
    void (Teacher:: * teacherSingal)() = &Teacher::hungry;
    void (Student:: * studentSlot)() = &Student::treat;
    connect(te,teacherSingal,st,studentSlot);
    //有参
    void (Teacher:: * teacherSingal2)(QString) = &Teacher::hungry;
    void (Student:: * studentSlot2)(QString) = &Student::treat;
    connect(te,teacherSingal2,st,studentSlot2);
    //QT4的写法
 //   connect(te,SIGNAL(hungry(QTstring)),st,SLOT(trea(QTstring)));
    //这么写编译不会报错,编译器检查不到
 //   connect(te,SIGNAL(hungry(void)),st,SLOT(trea(QTstring)));
        
    //3. 主动触发信号
     //   classIsOver();
    //触发老师饿了的信号
    //触发自定义信号的关键字：emit
 //   emit te->hungry();
    //触发有参信号
 //   emit te->hungry("肉");
        
    //4. 点击按钮触发
    QPushButton *btn = new QPushButton("下课",this);
    //点击按钮调用当前类的classIsOver函数
 //   connect(btn,&QPushButton::clicked,this,&MyWidget::classIsOver);
    //点击按钮触发老师的hungry信号
    connect(btn,&QPushButton::clicked,te,teacherSingal);
    //信号和槽必须一一对应：这么写就不行，因为信号clicked是无参的，而槽teacherSingal2是有参的，所以报错
 //   connect(btn,&QPushButton::clicked,te,teacherSingal2);
        
     //Lambda表达式使用
    connect(btn,&QPushButton::clicked,this,[=](){
         btn->setText("hello");
    });
    //无参按钮信号调用有参槽函数
    connect(btn,&QPushButton::clicked,this,[=](){
         te->hungry("肉");
    });
    //点击按钮关闭窗口
    connect(btn,&QPushButton::clicked,this,[=](){
         this->close();
    });
           
    resize(600,400);
        
    //5. 断开信号和槽
    //断开老师学生之间的联系
 //   disconnect(te,teacherSingal2,st,studentSlot2);
 //   disconnect(te,teacherSingal,st,studentSlot);
    //断开按钮与老师
 //   disconnect(btn,&QPushButton::clicked,te,teacherSingal);
 }
 //触发老师饿了的信号
 //触发自定义信号的关键字：emit
 void MyWidget:: classIsOver(){
     //触发老师饿了的信号
     emit te->hungry();
     emit te->hungry("肉");
 }
 MyWidget::~MyWidget()
 {
        
 }

    2. Teacher类

       #ifndef TEACHER_H
 #define TEACHER_H
        
 #include <QObject>
        
 class Teacher : public QObject
 {
     Q_OBJECT
 public:
     explicit Teacher(QObject *parent = nullptr);
        
     /*
      * signals:用来写自定义的信号
      * 特点：
      * 返回值必须是void
      * 只需要声明，不需要实现
      * 信号可以有参数，可以 重载
     */
 signals:
     //老师饿了信号
     void hungry();
     //重载
     void hungry(QString foodName);
        
 public slots://自定义槽函数的地方
 };
        
 #endif // TEACHER_H
        
        
 #include "teacher.h"

 Teacher::Teacher(QObject *parent) : QObject(parent)
 {
        
 }

    3. Student类

       #ifndef STUDENT_H
 #define STUDENT_H
        
 #include <QObject>
        
 class Student : public QObject
 {
     Q_OBJECT
 public:
     explicit Student(QObject *parent = nullptr);
        
 signals:
 /*
  * public slots：自定义槽函数的地方，高版本的QT直接可以写在public下面，也可以写成全局函数
  *特点：
  *返回值必须是void
  * 槽函数需要声明也需要实现
  * 槽函数也可以有参数、重载
 */
 public slots:
     //学生请客的槽
     void treat();
     //重载
     void treat(QString foodName);
 };
        
 #endif // STUDENT_H
        
 #include "student.h"
 #include<QDebug>
        
 Student::Student(QObject *parent) : QObject(parent)
 {
        
 }
        
 void Student:: treat(){
        
     qDebug()<<"请老师吃饭";
 }
        
 void Student:: treat(QString foodName){
        
     //不转：请老师吃饭,老师吃: "肉"
     //    qDebug()<<"请老师吃饭,老师吃:"<<foodName;
     //转：请老师吃饭,老师吃: 肉
     //QString转char*,:toUtf8先转成：QByteArray，再转char*
      qDebug()<<"请老师吃饭,老师吃:"<<foodName.toUtf8().data();
 }
  3. 自定义信号槽需要注意的事项：
    1. 发送者和接收者都需要是QObject的子类（当然，槽函数是全局函数、Lambda 表达式等无需接收者的时候除外）；
    2. 信号和槽函数返回值是 void
    3. 信号只需要声明，不需要实现
    4. 槽函数需要声明也需要实现
    5. 槽函数是普通的成员函数，作为成员函数，会受到 public、private、protected 的影响；
    6. 使用 emit 在恰当的位置发送信号；
    7. 使用connect()函数连接信号和槽。
    8. 任何成员函数、static 函数、全局函数和 Lambda 表达式都可以作为槽函数
    9. 信号槽要求信号和槽的参数一致，所谓一致，是参数类型一致。
    10. 如果信号和槽的参数不一致，允许的情况是，槽函数的参数可以比信号的少，即便如此，槽函数存在的那些参数的顺序也必须和信号的前面几个一致起来。这是因为，你可以在槽函数中选择忽略信号传来的数据（也就是槽函数的参数比信号的少）。
  4. 信号槽的拓展
    1. 一个信号可以和多个槽相连
      1. 如果是这种情况，这些槽会一个接一个的被调用，但是它们的调用顺序是不确定的。
    2. 多个信号可以连接到一个槽
      1. 只要任意一个信号发出，这个槽就会被调用。
    3. 一个信号可以连接到另外的一个信号
      1. 当第一个信号发出时，第二个信号被发出。除此之外，这种信号-信号的形式和信号-槽的形式没有什么区别。
    4. 槽可以被取消链接
      1. 这种情况并不经常出现，因为当一个对象delete之后，Qt自动取消所有连接到这个对象上面的槽。
    5. 信号槽可以断开
      1. 利用disconnect关键字是可以断开信号槽的
    6. 使用Lambda 表达式
      1. 在使用 Qt 5 的时候，能够支持 Qt 5 的编译器都是支持 Lambda 表达式的。
      2. 在连接信号和槽的时候，槽函数可以使用Lambda表达式的方式进行处理。
  5. Qt4版本的信号槽写法
    1. connect(zt,SIGNAL(hungry(QString)),st,SLOT(treat(QString)));
    2. 这里使用了SIGNAL和SLOT这两个宏，将两个函数名转换成了字符串。
    3. 注意到connect()函数的 signal 和 slot 都是接受字符串，一旦出现连接不成功的情况，Qt4是没有编译错误的（因为一切都是字符串，编译期是不检查字符串是否匹配），而是在运行时给出错误。这无疑会增加程序的不稳定性。
    4. Qt5在语法上完全兼容Qt4，而反之是不可以的。

Lambda表达式

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

     [capture](parameters) mutable ->return-type
 {
 statement
 }

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

    1. 函数对象参数；
      1. []，标识一个Lambda的开始，这部分必须存在，不能省略。函数对象参数是传递给编译器自动生成的函数对象类的构造函数的。函数对象参数只能使用那些到定义Lambda为止时Lambda所在作用范围内可见的局部变量（包括Lambda所在类的this）。函数对象参数有以下形式：
        1. 空。没有使用任何函数对象参数。
        2. =。函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是值传递方式（相当于编译器自动为我们按值传递了所有局部变量）。
        3. &。函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是引用传递方式（相当于编译器自动为我们按引用传递了所有局部变量）。
        4. this。函数体内可以使用Lambda所在类中的成员变量。
        5. a。将a按值进行传递。按值进行传递时，函数体内不能修改传递进来的a的拷贝，因为默认情况下函数是const的。要修改传递进来的a的拷贝，可以添加mutable修饰符。
        6. &a。将a按引用进行传递。
        7. a, &b。将a按值进行传递，b按引用进行传递。
        8. =，&a, &b。除a和b按引用进行传递外，其他参数都按值进行传递。
        9. &, a, b。除a和b按值进行传递外，其他参数都按引用进行传递。
    2. 操作符重载函数参数；
      1. 标识重载的()操作符的参数，没有参数时，这部分可以省略。参数可以通过按值（如：(a,b)）和按引用（如：(&a,&b)）两种方式进行传递。
    3. 可修改标示符；

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

         QPushButton * myBtn = new QPushButton (this);
 QPushButton * myBtn2 = new QPushButton (this);
 myBtn2->move(100,100);
 int m = 10;
        
 connect(myBtn,&QPushButton::clicked,this,[m] ()mutable { m = 100 + 10; qDebug() << m; });
        
 connect(myBtn2,&QPushButton::clicked,this,[=] ()  { qDebug() << m; });
        
 qDebug() << m;
    4. 函数返回值；
      1. ->返回值类型，标识函数返回值的类型，当返回值为void，或者函数体中只有一处return的地方（此时编译器可以自动推断出返回值类型）时，这部分可以省略。
    5. 是函数体；
      1. {}，标识函数的实现，这部分不能省略，但函数体可以为空。

All content is licensed under CC BY-NC-SA

Buit with Jekyll and 3-Jekyll theme • Hosted on Github

Table of Contents