QT学习：03 信号与槽

--- title: framework-cpp-qt-03-信号与槽 EntryName: framework-cpp-qt-03-signal-slot date: 2020-04-09 13:51:02 categories: tags: - qt - c/c++ ---

章节描述：
信号和槽机制是 QT 的核心机制，因为有了信号与槽的编程机制，在 Qt 中处理界面各个组件的交互操作时变得更加直观和简单。

通过前面的学习和了解我们知道了信号与槽是实现界面响应的方式。

GUI 程序设计的主要内容就是对界面上各组件的信号进行响应，只需要知道什么情况下发射哪些信号，合理地去响应和处理这些信号就可以了。

信号-槽 机制介绍

信号和槽是一种高级接口，应用于对象之间的通信，它是 QT 的核心特性，也是 QT 区别于其它工具包的重要地方。信号和槽是 QT 自行定义的一种通信机制，它独立于标准的 C/C++ 语言。

因此要正确的处理信号和槽，必须借助一个称为 moc（Meta Object Compiler）的 QT 工具，该工具是一个 C++ 预处理程序，它为高层次的事件处理自动生成所需要的附加代码。

Qt 不是使用的“标准的” C++ 语言，而是对其进行了一定程度的“扩展”。所以有人会觉得 Qt 的程序编译速度慢，这主要是因为在 Qt 将源代码交给标准 C++ 编译器，如 gcc 之前，需要事先将这些扩展的语法去除掉。完成这一操作的就是MOC（Meta-Object Compiler, 元对象编译器） 。
换句话说，QT 的拓展语法就是由其实现的。

信号和槽能携带任意数量和任意类型的参数，它们是类型完全安全的，不会像回调函数那样产生 core dumps。

  • 类型完全安全：即信号的参数类型和参数个数同接受该信号的槽的参数类型和参数个数相同；不过，一个槽的参数个数是可以少于信号的参数个数的，但缺少的参数必须是信号参数的最后一个或几个参数。如果信号和槽的签名不符，编译器就会报错。

所有从 QObject 或其子类 ( 例如 Qwidget) 派生的类都能够包含信号和槽。

  • 当对象改变其状态时，信号就由该对象发射 (emit) 出去，这就是对象所要做的全部事情，它不知道另一端是谁在接收这个信号。
  • 槽(slot)用于接收信号，但它们是普通的对象成员函数。一个槽并不知道是否有任何信号与自己相连接。而且，对象并不了解具体的通信机制。
  • 一旦关联信号和槽，Qt就保证了适当的槽得到调用。即使关联的对象在运行时被删除，应用程序也不会出现崩溃。

信号与槽 和 设计模式中的观察者模式很类似：

当某个事件发生之后，比如，按钮检测到自己被点击了一下，它就会发出一个信号（signal）。这种发出是没有目的的，类似广播。如果有对象对这个信号感兴趣，它就会事先使用连接（connect）函数，意思是，用自己的一个函数（成为槽（slot））进行注册以便于处理这个信号。

也就是说，当信号发出时，被连接的槽函数会自动被回调。

这就类似观察者模式：当发生了感兴趣的事件，某一个操作就会被自动触发。（这里提一句，Qt 的信号槽使用了额外的处理来实现，并不是 GoF 经典的观察者模式的实现方式。）

元对象工具

元对象编译器 moc（meta object compiler）对 C++ 文件中的类声明进行分析并产生用于初始化元对象的 C++ 代码，元对象包含全部信号和槽的名字以及指向这些函数的指针。

moc 会读取标记了 Q_OBJECT 的头文件，生成以 moc_ 为前缀的文件，这个新生成的文件中包含有该类的元对象代码。

例如，假设我们有一个头文件 mysignal.h，在这个文件中包含有信号或槽的声明，那么在编译之前 moc 工具就会根据该文件自动生成一个名为 moc_mysignal.cpp 的 C++ 源文件并将其提交给编译器。

元对象代码是 signal/slot 机制所必须的。用 moc 产生的 C++ 源文件必须与类实现一起进行编译和连接，或者用 #include 语句将其包含到类的源文件中。moc 并不扩展 #include 或者 #define 宏定义 , 它只是简单的跳过所遇到的任何预处理指令。

信号

信号（Signal）就是在特定情况下被发射的事件。

例如：PushButton 最常见的信号就是鼠标单击时发射的 clicked() 信号，一个 ComboBox 最常见的信号是选择的列表项变化时发射的 CurrentIndexChanged() 信号。

当某个信号对其客户或所有者发生的内部状态发生改变，信号被一个对象发射。

只有定义过这个信号的类及其派生类能够发射这个信号。

当一个信号被发射时，与其相关联的槽将被立刻执行，就象一个正常的函数调用一样。信号-槽机制完全独立于任何 GUI 事件循环。只有当所有的槽返回以后发射函数（emit）才返回。

在Qt5 中，当一个信号与多个槽函数关联时，槽函数按照建立连接时的顺序依次执行。

A signal can be connected to many slots and signals. Many signals can be connected to one slot.

If a signal is connected to several slots, the slots are activated in the same order in which the connections were made,when the signal is emitted.

信号的声明是在头文件中进行的，QT 的 signals 关键字指出进入了信号声明区，随后即可声明自己的信号。siganls 没有 public、private、protected 等属性。

事实上，如果信号是 private 的，这个信号就不能在类的外面连接，也就没有任何意义。

例如，下面定义了三个信号：

signals:
    void mySignal();
    void mySignal(int x);
    void mySignalParam(int x,int y);

从形式上讲信号的声明与普通的 C++ 函数是一样的，但是信号却没有函数体定义，另外，信号的返回类型都是 void，不要指望能从信号返回什么有用信息。

信号由 MOC自动产生，它们不应该在 .cpp 文件中实现，应该在头文件中进行声明。

槽

槽（Slot）就是对信号响应的函数。与一般的c++函数一样，可以具有任何参数，也可以直接调用。

槽函数与一般的函数不同的是：槽函数可以与多个信号关联，当与其关联的信号被发射时，这个槽就会被自动执行。

槽可以有参数，但槽的参数不能有缺省值。既然槽是普通的成员函数，因此与其它的函数一样，它们也有存取权限。槽的存取权限决定了谁能够与其相关联。同普通的 C++ 成员函数一样，槽函数也分为三种类型，即 public slots、private slots 和 protected slots。

public slots：在这个区内声明的槽意味着任何对象都可将信号与之相连接。这对于组件编程非常有用，你可以创建彼此互不了解的对象，将它们的信号与槽进行连接以便信息能够正确的传递。

protected slots：在这个区内声明的槽意味着当前类及其子类可以将信号与之相连接。

private slots：在这个区内声明的槽意味着只有类自己可以将信号与之相连接。这适用于联系非常紧密的类。

槽的声明也是在头文件中进行的。例如，下面声明了三个槽：

public slots:
   void mySlot();
   void mySlot(int x);
   void mySignalParam(int x,int y);

信号与槽的关联

connect

通过调用 QObject 对象的 connect 函数来将某个对象的信号与另外一个对象的槽函数相关联，这样当发射者发射信号时，接收者的槽函数将被调用。

bool QObject::connect ( const QObject * sender, const char * signal,
   const QObject * receiver, const char * member ) [static]

描述：将发射者 (sender) 对象中的信号 signal 与接收者 (receiver) 中的槽函数(member)联系起来。

当指定信号 signal 时必须使用 QT 的宏 SIGNAL()，当指定槽函数时必须使用宏 SLOT()。

注意：

  • 如果发射者与接收者属于同一个对象的话，那么在 connect 调用中接收者参数可以省略。

  • 当信号和槽函数带有参数时，在 connect()函数里，要写明参数的类型，但可以不写参数名称。

connect(spinNum, SIGNAL(valueChanged(int)), this, SLOT(addFun(int));
  • 一个信号可以连接另外一个信号。
class MyWidget : public QWidget
{
public:
    MyWidget();
	...
signals:
    void aSignal();
	...
private:
	...
    QPushButton *aButton;
};

MyWidget::MyWidget()
{
    aButton = new QPushButton( this );
    connect( aButton, SIGNAL(clicked()), SIGNAL(aSignal()) );
}

在上面的构造函数中，MyWidget 创建了一个私有的按钮 aButton，按钮的单击事件产生的信号 clicked() 与另外一个信号 aSignal() 进行了关联。

这样一来，当信号 clicked() 被发射时，信号 aSignal() 也接着被发射。

disconnect

当信号与槽没有必要继续保持关联时，我们可以使用 disconnect 函数来断开连接。

bool QObject::disconnect ( const QObject * sender, const char * signal,
   const Object * receiver, const char * member ) [static]

描述：断开发射者中的信号与接收者中的槽函数之间的关联。

注意：在 disconnect 函数中 0 可以用作一个通配符，分别表示任何信号、任何接收对象、接收对象中的任何槽函数。但是发射者 sender 不能为 0，其它三个参数的值可以等于 0。

用法：

1、断开与某个对象相关联的任何对象。事实上，当我们在某个对象中定义了一个或者多个信号，这些信号与另外若干个对象中的槽相关联，如果我们要切断这些关联的话，就可以利用这个方法，非常之简洁。

disconnect( myObject, 0, 0, 0 )
// 或者
myObject->disconnect()

2、断开与某个特定信号的任何关联。

disconnect( myObject, SIGNAL(mySignal()), 0, 0 )
// 或者
myObject->disconnect( SIGNAL(mySignal()) )

3、断开两个对象之间的关联。

disconnect( myObject, 0, myReceiver, 0 )
// 或者
myObject->disconnect(  myReceiver )

程序样例

使用connect()可以让我们连接系统提供的信号和槽。但是，Qt 的信号槽机制并不仅仅是使用系统提供的那部分，还会允许我们自己设计自己的信号和槽。这也是 Qt 框架的设计思路之一，用于我们设计解耦的程序。本节将讲解如何在自己的程序中自定义信号槽。

信号槽不是 GUI 模块提供的，而是 Qt 核心特性之一。因此，我们可以在普通的控制台程序使用信号槽。

经典的观察者模式在讲解举例的时候通常会举报纸和订阅者的例子。

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

在这个例子中，观察者是Subscriber，被观察者是Newspaper。在经典的实现代码中，观察者会将自身注册到被观察者的一个容器中（比如subscriber.registerTo(newspaper)）。被观察者发生了任何变化的时候，会主动遍历这个容器，依次通知各个观察者（newspaper.notifyAllSubscribers()）。

我们来看这个例程，添加2个头文件：

  • newspaper.h
#ifndef NEWSPAPER_H
#define NEWSPAPER_H
#include <QCoreApplication>
#include <QObject>
#include <QDebug>
class Newspaper : public QObject
{
    Q_OBJECT
public:
    Newspaper(const QString & name) :
        m_name(name)
    {
    }
    // 定义一个send方法，将 name 发送出去
    void send()
    {
        emit newPaper(m_name);
    }

signals:
    void newPaper(const QString & name);

private:
    QString m_name;
};
#endif // NEWSPAPER_H
  • reader.h
#ifndef READER_H
#define READER_H
#include <QCoreApplication>
#include <QObject>
#include <QDebug>

class Reader : public QObject
{
    //Q_OBJECT 由于不一定需要使用 slots， 所以也可以不使用 这个宏
public:
    Reader() {}
// public slots: 
// Qt 5 中，任何成员函数、static 函数、全局函数和 Lambda 表达式都可以作为槽函数。所以不一定需要 slots 声明。
    // 槽函数
    void receiveNewspaper(const QString &name)
    {
        qDebug() << "Receives Newspaper: " << name;
    }
};
#endif // READER_H
  • main.cpp
#include <QCoreApplication>
#include <QObject>
#include <QDebug>

#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.h 和 reader.h 都放在 main.cpp 的main()函数之前吗？答案：可以，但是比较麻烦。

解决方法：

1)手动调用 moc 工具处理 main.cpp，类似moc xx.h -o moc_xx.cpp

2)并且将 main.cpp 中的#include "newspaper.h"改为#include "moc_newspaper.h"就可以了。

为了避免这样繁琐的修改，我们还是将其放在头文件中。

许多初学者会遇到莫名其妙的错误，一加上Q_OBJECT就出错，很大一部分是因为没有注意到这个宏应该放在头文件中。

QObject 关键字

首先看Newspaper这个类。这个类继承了QObject类。只有继承了QObject类的类，才具有信号槽的能力。所以，为了使用信号槽，必须继承QObject。

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

注意，这个宏将由 moc 做特殊处理，不仅仅是宏展开这么简单。moc 会读取标记了 Q_OBJECT 的头文件，生成以 moc_ 为前缀的文件，比如 newspaper.h 将生成 moc_newspaper.cpp。你可以到构建目录查看这个文件，看看到底增加了什么内容。

signals 关键字

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

我们曾经说过，Qt 程序能够使用普通的 make 进行编译。没有实现的函数名怎么会通过编译？原因还是在 moc，moc 会帮我们实现信号函数所需要的函数体，所以说，moc 并不是单纯的将 Q_OBJECT 展开，而是做了很多额外的操作。

emit 关键字

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

slot 槽函数

Reader类更简单。因为这个类需要接受信号，所以我们将其继承了QObject，并且添加了Q_OBJECT宏。后面则是默认构造函数和一个普通的成员函数。Qt 5 中，任何成员函数、static 函数、全局函数和 Lambda 表达式都可以作为槽函数。与信号函数不同，槽函数必须自己完成实现代码。

connect 函数

main()函数中，我们首先创建了Newspaper和Reader两个对象，然后使用QObject::connect()函数。将信号-槽连接起来。然后我们调用Newspaper的send()函数。这个函数只有一个语句：发出信号。

由于我们的连接，当这个信号发出时，自动调用 reader 的槽函数，打印出语句。

connect连接的4种写法

为方便演示，先自定义一个 Button，然后定义两个重载的信号

class MyButton : public QWidget
{
    Q_OBJECT
public:
    explicit MyButton(QWidget *parent = nullptr);

signals:
    void sigClicked();
    void sigClicked(bool check);
};

老版本

老版本的 connect 写法比较复杂：需要将信号和槽进行明确的指定，包括形参。

在用这个 Button 的时候连接这两个信号，按照旧版本的写法，应该是这样：

connect(m_pBtn,SIGNAL(sigClicked()),this,SLOT(onClicked()));
connect(m_pBtn,SIGNAL(sigClicked(bool)),this,SLOT(onClicked(bool)));

这种写法比较麻烦，常常在用的时候缺少括号，不过该写法很明确，一眼就能看出来是将哪个信号连接到哪个槽。

基于函数地址

接着上面的示例，在 Qt5.0以后推出一种新的写法，如下：

connect(m_pBtn,&MyButton::sigClicked,this,&Widget::onClicked);

这种写法看起来很简洁，但是存在一些坑需要注意，这句写法如果用在上面的示例中，会报错下面的错误：

error: no matching member function for call to 'connect'  connect(m_pBtn,&MyButton::sigClicked,this,&Widget::onClicked);
    ^~~~~~~

这是因为我们自定义的 Button 中存在两个重载信号，然后用这种 connect 的方式会无法识别到底想要连接哪个信号。所以，如果信号是重载的话，需要用下面的写法来替换：

connect(m_pBtn, static_cast<void (MyButton::*)(bool)>(&MyButton::sigClicked), this, &Widget::onClicked);

问题又来了，如果我的onClicked槽也是重载的话，还是会报同样的错误。因为编译器不知道你想要真正连接哪个槽。所以这里建议，如果信号重载，可以用上面的方法来写，如果槽重载…还是用第一种方法来 connect 吧，比较保险，虽然比较麻烦点。

最新的写法

主要针对重载信号的连接做了调整，会更简单些。同样是上面的示例：

connect(m_pBtn, QOverload<bool>::of(&MyButton::sigClicked),this,&Widget::onClicked);

很显然这种写法相对于第二种会比较简单些，但依然不能连接到重载的槽函数，如果连接重载槽函数，还是会报之前的错误。

Lambda 函数写法

个人比较喜欢用lambda函数的方式，如果槽函数中的内容比较简单的话，没必要再去单独定义一个槽来连接， 直接用Lambda 函数会更简单。

来看一下示例：

connect(m_pBtn, QOverload<bool>::of(&MyButton::sigClicked),
          [=](bool check){
        /* do something.. */ 
    });
    
connect(m_pBtn, static_cast<void (MyButton::*)(bool)>(&MyButton::sigClicked), this, [=](bool check){
        //do something
    });

附录：信号槽 的 限制

信号与槽机制是比较灵活的，但也有它的使用限制。

1 ）信号与槽的效率是非常高的。但是同真正的回调函数比较起来，由于增加了灵活性，因此在速度上还是有所损失。

当然这种损失相对来说是比较小的，通过在一台 i586-133 的机器上测试是 10 微秒（运行 Linux），可见这种机制所提供的简洁性、灵活性还是值得的。但如果我们要追求高效率的话，比如在实时系统中就要尽可能的少用这种机制。

2 ）信号与槽机制与普通函数的调用一样，如果使用不当的话，在程序执行时也有可能产生死循环。因此，在定义槽函数时一定要注意避免间接形成无限循环，即在槽中再次发射所接收到的同样信号。

例如 , 在前面给出的例子中如果在 mySlot() 槽函数中加上语句 emit mySignal() 即可形成死循环。

3）宏定义不能用在 signal 和 slot 的参数中， moc 工具不扩展 #define。

#ifdef ultrix
#define SIGNEDNESS(a) unsigned a
#else
#define SIGNEDNESS(a) a
#endif

class Whatever : public QObject
{
...
    
signals:
    void someSignal( SIGNEDNESS(a) );
    
...
};

4）构造函数不能用在 signals 或者 slots 声明区域内。

class SomeClass : public QObject
{
    Q_OBJECT
public slots:
    SomeClass( QObject *parent, const char *name )
        : QObject( parent, name ) {}  // 在槽声明区内声明构造函数不合语法
[...]
};

5）函数指针不能直接作为信号或槽的参数。

例如，下面的例子中将void (*applyFunction)(QList*, void*)作为参数是不合语法的：

class someClass : public QObject
{
    Q_OBJECT
[...]
public slots:
    void apply(void (*applyFunction)(QList*, void*), char*); // 不合语法
};

你可以采用下面的方法绕过这个限制：

typedef void (*ApplyFunctionType)(QList*, void*);
class someClass : public QObject
{
    Q_OBJECT
[...]
public slots:
    void apply( ApplyFunctionType, char *);
};

6）信号与槽也不能直接携带模板类参数。

如果将信号、槽声明为模板类参数的话，即使 moc 工具不报告错误，也不可能得到预期的结果。 例如，下面的例子中当信号发射时，槽函数不会被正确调用：

[...]
public slots:
    void MyWidget::setLocation (pair<int,int> location);
[...]
public signals:
    void MyObject::moved (pair<int,int> location);

但是，你可以使用 typedef 语句来绕过这个限制。如下所示：

typedef pair<int,int> IntPair;

[...]
public slots:
    void MyWidget::setLocation (IntPair location);
[...]
public signals:
    void MyObject::moved (IntPair location);

这样使用的话，你就可以得到正确的结果。

7）嵌套的类不能位于信号或槽区域内，也不能有信号或者槽。

class A
{
    Q_OBJECT
public:
    class B
{
    public slots:   // 在嵌套类中声明槽不合语法
        void b();
    [....]
    };
signals:
    class B
{
    // 在信号区内声明嵌套类不合语法
    void b();
    [....]
    }:
};

8）友元声明不能位于信号或者槽声明区内。

class someClass : public QObject
{
    Q_OBJECT
[...]
signals: // 信号定义区
    friend class ClassTemplate; // 此处定义不合语法
};

9）发送者和接收者都需要是QObject的子类，但接收者可以不需要使用Q_OBJECT宏

当然，槽函数是全局函数、Lambda 表达式等无需接收者的时候除外。

posted @ 2020-04-09 13:51  schips  阅读(804)  评论(0)  编辑  收藏  举报