Qt 信号槽原理 - 槽函数调用时机

置顶 已于 2024-03-06 22:53:13 修改
阅读量2.7k 收藏 54
点赞数 58
分类专栏： Qt 文章标签： qt 开发语言 c++ 学习
于 2024-01-03 20:06:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62381297/article/details/135360576
版权

目录

前言

因为之前学习 Qt 多线程时，使用信号槽发现槽函数没有执行，想到我还完全不清楚槽函数的调用时机，于是心血来潮翻了一下这部分的源码，现在记录顺便复习一下。学习一下后发现，当时信号调用是在主线程，也就是 UI 线程，接收对象在另一个新开的线程里，使用 moveToThread 把它移过去了，那个线程有正在执行的函数，我在主线程调用信号，会异步投递一个槽函数相关的事件过去，这个事件需要那个线程回到 eventLoop 中才能处理，而那个线程还在执行一个函数，还没轮到这个事件！

本文主要介绍我所认知的槽函数的调用时机

一 Qt 元对象系统

在学习信号槽之前简单了解一下 Qt 的元对象系统（Meta-Object System）
Qt 的元对象系统提供了对象之间通信的信号槽机制、运行时类型信息和动态属性系统等
元对象系统由以下三个基础组成：

  • QObject 类是所有使用元对象系统的类的基类；
  • 在类中声明 Q_OBJECT 宏，使得类可以使用元对象系统特性，如信号槽；
  • MOC（元对象编译器）为每一个 QObject 的子类提供必要的代码来实现元对象系统特性

所以，自定义的类想要使用信号槽，必须继承自 QObject，同时在类中声明 Q_OBJECT 宏

二 创建测试工程

了解上面的东西后，我们先创建一个工程来体会一下

使用 QtCreator 正常创建一个桌面应用程序，我们添加一个自定义类，
添加自定义类

#ifndef OBJECT_H
#define OBJECT_H

#include <QObject>

class Object : public QObject
{
    Q_OBJECT
public:
    explicit Object(QObject *parent = nullptr);

signals:

};

#endif // OBJECT_H

添加时继承自 QObject，并勾选 Add Q_OBJECT，模板已经帮我们完成了前面两个工作，然后我们添加一些信号函数和槽函数，

#ifndef OBJECT_H
#define OBJECT_H

#include <QObject>

class Object : public QObject
{
    Q_OBJECT
public:
    explicit Object(QObject *parent = nullptr);
    
public slots:
    void click() {}
    void hide() {}
    
signals:
    void clicked(bool checked);
    void pressed();
    void sendMessage(const QString &msg, int id);
};

#endif // OBJECT_H

这里需要注意：

  • 信号函数必须声明在 signals 后面，不需要 public 那些访问限制的修饰，并且只需要声明，不需要实现；
  • 槽函数可以声明在 slots 后面，可以使用 public、private 等修饰，这样声明的槽函数就可以在 QObject::connect 函数中使用 SLOT 宏来指定槽。也可以使用 connect 的其他重载，直接使用成员函数指针或者 lambda 函数

然后我们点击左下角的构建项目，在可执行文件目录下，可以看到这些以 moc_ 开头的 cpp 文件，

这就是第三点，MOC 元对象编译器给每一个 QObject 子类生成的代码，这里再强调：

  • 这个类必须继承自 QObject，直接（我们的 Object 类）或间接（Widget）
  • 必须声明 Q_OBJECT 宏，如果没有这个宏，就不会生成对应的 moc_xxx.cpp

也就是说 Qt 项目的构建过程除了标准 C++ 程序的预处理、编译、链接，还有第 0 步，生成这些 Qt 特性的文件。

这里插一句，如果一开始没有继承 QObject，后面想使用信号槽，将类继承 QObject 和添加 Q_OBJECT 后，但出了下面的问题：

错误

解决方案是右键项目重新执行 qmake，然后构建就能成功了（我也不清楚是啥原因，但是你用 QtCreator 写 Qt 项目时，构建出问题了，实在没啥办法，可以试试删除 build 文件夹，改动一下 .pro 文件，加一个空格也行，重新执行 qmake，清除重新构建，或者重启 QtCreator等等）

三 逐步探索

好嘞，下面我们就从这个 moc_object.cpp 文件开始逐步探索吧！！！

1. qt_static_metacall

当然，里面很多东西我也看不懂，我们先看两处关键的代码，在 qt_static_metacall 函数中，

void Object::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<Object *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->clicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->pressed(); break;
        case 2: _t->sendMessage((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
        case 3: _t->click(); break;
        case 4: _t->hide(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
		...
    }
}

可以看到里面的 switch 语句，是不是就是在调用我们的槽函数，同时还有信号函数，因为信号也能被另一个信号触发，即信号可以连接槽函数，也能连接信号函数。这样我们就能猜测到从信号函数被调用，到最终调用槽函数，应该就发生在这里！

2. 信号函数的实现

然后文件最下面就是我们在 signals 后面声明的三个信号函数，之前说了信号函数我们只需声明，不需要实现，自动生成的代码给我们实现了，下面我们来看看，一点不复杂，

// SIGNAL 0
void Object::clicked(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Object::pressed()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void Object::sendMessage(const QString & _t1, int _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

我们声明的三个信号函数，参数的个数不一样，声明的位置（顺序）不一样，这里就可以看出有什么区别了

  1. 注意到 // SIGNAL 0 这些带有编号的，这个很重要，可以看到函数里面的 QMetaObject::activate 的参数里面就带着这个编号，其实就是索引（从 0 开始的嘛），也就是信号函数它们被组织起来了，每个信号函数有对应的索引

  2. 它们的参数不同，函数中的 void *_a[ ] 也不同，第二个函数没有声明，其实就是 QMetaObject::activate 参数里面的 nullptr，这个_a[ ] 特点就是第一个元素是 nullptr，后面就是每一个参数的地址，这就是一个参数列表，是不是和 main 函数的参数 char *argv[ ] 比较像

3. QMetaObject::activate

最后就是这个 QMetaObject::activate，这里就要翻源码了，这里可以在线阅读很多 C/C++ 项目的源码 Code browser

这个 activate 函数有三个重载，信号函数中调用的应该是这一个重载

void QMetaObject::activate(QObject *sender, 
						   const QMetaObject *m, 
						   int local_signal_index,
						   void **argv)
{
    int signal_index = local_signal_index + QMetaObjectPrivate::signalOffset(m);

    if (Q_UNLIKELY(qt_signal_spy_callback_set.loadRelaxed()))
        doActivate<true>(sender, signal_index, argv);
    else
        doActivate<false>(sender, signal_index, argv);
}

再看一下参数：

  • sender，这个信号所属类的对象，发送者
  • m，在之前的 moc 文件中有这样一个定义，activate 函数里就是用这个对象
QT_INIT_METAOBJECT const QMetaObject Object::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_meta_stringdata_Object.data,
    qt_meta_data_Object,
    qt_static_metacall,
    nullptr,
    nullptr
} };
  • local_signal_index，与信号函数相关的索引
  • argv，信号函数的参数列表

经过处理后，然后就是调用了一个模板函数 doActivate，这个函数有 170 来行，关键的内容就在这里面了

template <bool callbacks_enabled>
void doActivate(QObject *sender, int signal_index, void **argv)

4. doActivate

这个函数内容很多，牵扯的东西比较多，所以很多都看不懂，下面我就挑一些看得懂、关键的来介绍

template <bool callbacks_enabled>
void doActivate(QObject *sender, int signal_index, void **argv) {
//...
	void *empty_argv[] = { nullptr };
	if (!argv)
	    argv = empty_argv;
//...
}

之前我们有一个信号函数的参数为空，这里面就把那个参数列表给补上了，仍然是第一个元素是 nullptr

template <bool callbacks_enabled>
void doActivate(QObject *sender, int signal_index, void **argv) {
	// 获得发送对象的 d 指针
	QObjectPrivate *sp = QObjectPrivate::get(sender);
//...
	QObjectPrivate::ConnectionDataPointer connections(sp->connections.loadRelaxed());
    QObjectPrivate::SignalVector *signalVector = connections->signalVector.loadRelaxed();

    const QObjectPrivate::ConnectionList *list;
    if (signal_index < signalVector->count())
        list = &signalVector->at(signal_index);
    else
        list = &signalVector->at(-1);
//...
}

这里就稍微复杂了，简单总结就是，函数第一行获取发送对象 sender 的 d 指针，最后得到了一个 ConnectionList *list，一个单链表，每一个元素都是一个 Connection 结构体，就是通过 QObject::connect 函数连接信号和槽时得到的一个结构体

// ConnectionList is a singly-linked list
struct ConnectionList {
     QAtomicPointer<Connection> first;
     QAtomicPointer<Connection> last;
 };

struct Connection : public ConnectionOrSignalVector
{
	...
    // linked list of connections connected to signals in this object
    QAtomicPointer<Connection> nextConnectionList;
    Connection *prevConnectionList;
    QObject *sender;
    QAtomicPointer<QObject> receiver;
    QAtomicPointer<QThreadData> receiverThreadData;
    union {
        StaticMetaCallFunction callFunction;
        QtPrivate::QSlotObjectBase *slotObj;
    };
    ushort method_offset;
    ushort method_relative;
    signed int signal_index : 27; // In signal range (see QObjectPrivate::signalIndex())
    ushort connectionType : 3; // 0 == auto, 1 == direct, 2 == queued, 4 == blocking
    ...
};

一个 Connection 对象里面存储了很多重要信息

  • QObject *sender：发送对象 sender
  • signed int signal_index：与信号函数有关的 index
  • QAtomicPointer<QObject> receiver：接收对象 receiver
  • QAtomicPointer<QThreadData> receiverThreadData：接收对象所在线程的线程数据
  • StaticMetaCallFunction callFunction：和之前 moc 文件中的 qt_static_metacall 函数有关
  • ushort connectionType：QObject::connect 的第五个参数

既然得到了一个 Connection 链表，很容易想到下面就是对这个链表进行遍历然后调用与槽函数有关的函数了

先不急着遍历，有一个很重要的信息就是 connect 的第五个参数，连接类型，连接类型主要是考虑到信号函数调用时所在的线程，和接收对象所在线程的关系，下面一开始得到的 inSenderThread 表示当前调用这个信号函数的线程是不是在 sender 对象所在的线程，后面马上要用


Qt::HANDLE currentThreadId = QThread::currentThreadId();
bool inSenderThread = currentThreadId == QObjectPrivate::get(sender)->threadData.loadRelaxed()->threadId.loadRelaxed();

// We need to check against the highest connection id to ensure that signals added
// during the signal emission are not emitted in this emission.
uint highestConnectionId = connections->currentConnectionId.loadRelaxed();
do {
    QObjectPrivate::Connection *c = list->first.loadRelaxed();
    if (!c)
        continue;

    do {
        QObject * const receiver = c->receiver.loadRelaxed();
        if (!receiver)
            continue;

        QThreadData *td = c->receiverThreadData.loadRelaxed();
        if (!td)
            continue;

        bool receiverInSameThread;
        if (inSenderThread) {
            receiverInSameThread = currentThreadId == td->threadId.loadRelaxed();
        } else {
            // need to lock before reading the threadId, because moveToThread() could interfere
            QMutexLocker lock(signalSlotLock(receiver));
            receiverInSameThread = currentThreadId == td->threadId.loadRelaxed();
        }

		...// 下面就是关键

    } while ((c = c->nextConnectionList.loadRelaxed()) != nullptr && c->id <= highestConnectionId);

} while (list != &signalVector->at(-1) &&
    //start over for all signals;
    ((list = &signalVector->at(-1)), true));

然后开始遍历，两个 do while 循环，主要看内层的循环（这个外层循环的 while 条件有点看不懂），得到一个 Connection 对象然后进行操作

然后得到接收对象相关的线程信息，还是先判断线程的关系，这里通过 inSenderThread 条件，考虑是否先上锁来获取 receiverInSameThread，表示接收对象 receiver 是否在这个信号函数调用所在的线程

  • 接收对象就在这个线程里，立即准备执行槽函数的相关函数
  • 接收对象不在这个线程里，则通过事件机制来做异步处理

下面就来看 Qt 是怎么处理的吧

...// 下面就是关键

// determine if this connection should be sent immediately or
// put into the event queue
if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread)
    || (c->connectionType == Qt::QueuedConnection)) {
    queued_activate(sender, signal_index, c, argv);
    continue;
#if QT_CONFIG(thread)
} else if (c->connectionType == Qt::BlockingQueuedConnection) {
    ... // postEvent，向接收对象投递一个 QMetaCallEvent
    continue;
#endif
}
// ... 后面是同步调用槽函数

异步处理

连接类型默认是 Qt::AutoConnection，这里代码自己判断是不是在同一个线程，如果不在同一个线程，则需要通过事件机制来处理：

  • Qt::QueuedConnection：调用了 queued_activate，里面使用了 QCoreApplication::postEvent 投递一个 QMetaCallEvent 事件
  • Qt::BlockingQueuedConnection：直接在这里投递事件，并且使用了一个信号量来阻塞，直到槽函数执行完

先判断是否需要异步处理，处理完后 continue，继续下一个 Connection。如果不是异步处理，则在这里直接调用槽函数，接着往下看

同步处理

这里有一个 if else 分支，这里就简化看一下（具体的自己看源码吧），针对不同条件来处理，关键就这三个函数

// ... 后面是同步调用槽函数

if (c->isSlotObject) {
	...
	obj->call(receiver, argv);
	...
} else if (c->callFunction && c->method_offset <= receiver->metaObject()->methodOffset()) {
	...
	callFunction(receiver, QMetaObject::InvokeMetaMethod, method_relative, argv);
	...
} else {
	...
	QMetaObject::metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv);
	...
}

其中的 callFunction 和 QMetaObject::metacall 的参数不就和 moc 文件里的 qt_static_metacall 函数对应上了？！

int QMetaObject::metacall(QObject *object, Call cl, int idx, void **argv)
{
    if (object->d_ptr->metaObject)
        return object->d_ptr->metaObject->metaCall(object, cl, idx, argv);
    else
        return object->qt_metacall(cl, idx, argv);
}

可是这个函数名也没对上啊，原来，moc 文件中还有一个函数 qt_metacall，里面就调用了最后的 qt_static_metacall

int Object::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
		...
    }
    return _id;
}

最后，终于回到了这个函数，调用了具体的槽函数。 doActivate 函数稍微有点复杂，建议看源码

void Object::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<Object *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->clicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->pressed(); break;
        case 2: _t->sendMessage((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
        case 3: _t->click(); break;
        case 4: _t->hide(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        ...
    }
}

总结

从信号函数到这里一路流水账，中间有很多细节没有处理，但是不需要在意，另外使用信号槽还有 lambda 等方式，这种连接的话，流程我不是很清楚

总之只要记住槽函数的同步和异步调用就行了，最后再总结一下：

  • 继承 QObject，添加 Q_OBJECT 宏
  • 信号函数必须声明在 signals 后面
  • 槽函数声明在 slots 后面，可以理解槽函数就是正常的成员函数，可以用在 SLOT 宏里面
  • moc 为我们实现了信号函数、生成了 qt_static_metacall 函数
  • 是信号函数被调用时所在的线程和接收对象所在的线程比较，不是发送对象和接收对象
  • 异步处理时使用了事件机制，通过 postEvent 投递一个事件给接收对象（先投递给它所在的线程，线程对应的事件循环把事件发送给对象）
  • 同步处理也就是直接在信号函数里面调用了槽函数
  • 每个信号函数都关联了一个 ConnectionList，进行遍历处理，可以理解为观察者模式

希望能帮你理解到槽函数的调用时机，关于异步处理，可以先简单理解为生产者消费者模式，具体请先了解事件机制~
想了解异步处理可以看我下一篇文章 Qt 信号槽原理 - 多线程时槽函数调用时机

本人实力有限，只看得懂部分源码，可能会断章取义，如果有什么错误欢迎友好交流讨论
本文为个人学习记录，转载引用请注明出处

Jay森～
关注
专栏目录
QT信号槽connect函数详解
qq_30725967的博客
08-02 2748
使用QT开发时，通常使用connect函数只传递四个参数： connect(Sender,SIGNAL(signal),Receiver,SLOT(slot)); 所以我们有可能认为该函数就只有四个参数，但实际上是有第五个参数的，只是通常该函数已经给第五个参数赋值了而已，我们所使用的是默认值。 实际上connect函数应该是如下形式： connect(sender,SIGNAL(signa...
QT信号槽机制理解
qq_43341440的博客
06-11 644
1. 信号和槽概述 > 信号槽是 Qt 框架引以为豪的机制之一。所谓信号槽，实际就是观察者模式(发布-订阅模式)。当某个`事件`发生之后，比如，按钮检测到自己被点击了一下，它就会发出一个信号（signal）。这种发出是没有目的的，类似广播。如果有对象对这个信号感兴趣，它就会使用连接（connect）函数，意思是，将想要处理的信号和自己的一个函数（称为槽（slot））绑定来处理这个信号。也就是说，当信号发出时，被连接的槽函数会自动被回调。这就类似观察者模式：当发生了感兴趣的事件，某一个操作就会被自动触
QT--信号和槽机制
最新发布
weixin_63775160的博客
03-19 551
1，确定功能2，添加发送类和接收类3，发送类声明信号，接收类声明并实现槽函数-信号：信号返回值为void，参数可以存在，仅声明不需要实现，可以重载signals:-槽函数：一般在public slots里面写，对于一些高版本qt来说，也可以写到public或全局变量；返回值void，参数可以存在，需要声明并实现，可以重载4,创建发送对象，接收对象。
QT 信号槽之一：九种基础调用方式
翕翕堂
10-19 1787
前提 环境：Qt Creator 5.0.1，Qt 6.1.3 背景描述：信号槽机制，是qt中最基础的消息机制，下面的使用方式，都是基于qt6的最基础使用方式（扩展使用方式以后再慢慢补充）包括： 固定的信号槽使用 固定的信号槽使用，使用父类 自定义信号槽，无重载信号槽时 自定义信号槽，有重载信号槽时，带参信号槽，函数指针 信号连接信号 多个信号可以连接一个槽函数 一个信号可以连接多个槽函数 信号参数个数可以多于槽参数个数，但是类型顺序必须相同 lambda表达式实现槽函数 基础 co
【小沐学QT】QT学习之信号槽使用
爱看书的小沐
02-29 2548
在GUI编程中，当我们更改一个小部件时，我们通常希望通知另一个小程序。更普遍地说，我们希望任何种类的物体都能够相互通信。例如，如果用户单击“关闭”按钮，我们可能希望调用窗口的Close()函数。其他工具包使用回调实现这种通信。回调是指向函数的指针，因此，如果您希望处理函数通知您某个事件，您可以将指向另一个函数的指针（回调）传递给处理函数。然后，处理函数在适当的时候调用回调。虽然使用这种方法的成功框架确实存在，但回调可能是非直观的，并且在确保回调参数的类型正确性方面可能会遇到问题。
Qt 信号如何触发槽函数？
枫焱宇的博客
04-15 1463
概述 因为Qt的MOC编译器在预处理的时候实现了信号函数，信号函数的实质就是调用了doActivate模板函数，这篇就单独拿出来记录一下。 正文 先看源代码：（注意中文注释） template <bool callbacks_enabled> void doActivate(QObject *sender, int signal_index, void **argv) { QObjectPrivate *sp = QObjectPrivate::get(sender); //
Qt 信号槽原理 - 多线程时槽函数调用时机
qq_62381297的博客
01-04 1740
Qt 信号槽跨线程时发生了什么？事件循环中发生了什么？通过源码简单了解一下吧
QT(42)-QT线程-线程调用槽函数
aggie4628的专栏
08-04 2983
当槽函数运行时间比较长时，为了效率，用线程而非主程序调用槽函数。
qt信号发送间隔短而槽耗时多_Qt信号槽问题汇总 - osc_9q1dp3jk的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_42347465的博客
02-11 1157
1. 发送一次信号，调用多次槽函数问题在同一个类中，多次链接QObject::connect(sender, SIGNAL(signalSender(QString, int)), receiver, SLOT(onSignalSender(QString, int))); 会导致发送一次信号signalSender(QString, int) 多次调用槽函数(onSignalSender(QSt...
qt之信号与槽的原理
没闲的小孩多酱
03-22 1万+
只要问到qt的亮点是什么，不得不说就是信号与槽机制。信号与槽类似观察者模式。 在面向对象的编程中，都会创建很多实例，而每个实例都是独立的，要想每个实例能够协同合作，那么就会需要一种对象间传递消息的机制，在很多框架中都采用回调函数来进行对象间信息传递。 回调函数就是一个函数指针，如果想要一个处理函数通知一些事件，你需要将这个指针传递给处理函数。处理函数在适当时间调用回调函数。MFC就是使用的回调...
QT 原理1 信号槽信息的存储1
08-03
在这个例子中，我们将深入理解QT信号槽的工作原理，特别是涉及到的元对象系统（Meta-Object System）。 首先，我们看`CStudent`类，它继承自`QObject`，并且使用了`Q_OBJECT`宏。这个宏使得`QObject`的元对象系统...
Qt槽函数的几种用法
qq_45076095的博客
03-09 1万+
Qt槽函数的几种用法通过ui控件添加槽函数通过connect连接 通过ui控件添加槽函数 这种方法是在Qt的ui文件中，添加一个控件，然后点击右键，选择具体的槽函数，具体操作如下： 新建一个Qt项目（略过） 点击ui文件 添加一个控件（这里添加一个按钮（PushButton）） 右键按钮控件 选择相应的事件(这里选择clicked) 在mainwindow.h和mainwindow.cpp中会自动添加两段代码，如下： 然后就可以在函数中添加相关代码来实现。 通过connect连接 **1、首先介
Qt中槽函数的几种方法
2301_80434259的博客
01-29 2109
SLOT(pushButton1())`: 接收信号后调用的槽函数，表示调用当前对象的 `pushButton1()` 成员函数。把按钮的objectName，声明为void on_objectName_clicked();第一种已经完成，`ui->pushButton`: 信号发出者，表示界面上的按钮对象。`SIGNAL(clicked(bool))`: 发出的信号，表示按钮被点击。替换为如下代码，然后不需要按前面的操作声明和定义槽函数，直接lambda定义。`this`: 信号接收者，表示当前对象。
学习QT之信号槽机制详解
贝勒里恩的博客
03-05 1786
学习QT之信号槽机制详解 一、Qt信号槽机制 概念：信号槽是Qt框架引以为豪的机制之一。所谓信号槽，实际就是观察者模式。当某个事件发生之后，比如：按钮检测到自己被点击了一下，它就会发出一个信号（signal）。这种发出是没有目的的，类似广播。如果有对象对这个信号感兴趣，他就会使用连接（connect）函数，意思是，将想要处理的信号和自己的一个函数（称为槽（slot））绑定来处理这个信号。也就是说，...
信号槽如何传递参数（或带参数的信号槽）
热门推荐
分享的滋味
09-26 6万+
信号槽如何传递参数（或带参数的信号槽） 利用Qt进行程序开发时，有时需要信号槽来完成参数传递。带参数的信号槽在使用时，有几点需要注意的地方，下面结合实例进行介绍。 第一点：当信号与槽函数的参数数量相同时，它们参数类型要完全一致。 信号： void iSignal(int b); 槽： void MainWindow::iSlot(int b) { QSt
10 QT - 自定义信号和槽
阿甘兄
10-18 1208
使用connect()可以让我们连接系统提供的信号和槽。但是，Qt 的信号槽机制并不仅仅是使用系统提供的那部分，还会允许我们自己设计自己的信号和槽。 下面我们看看使用 Qt 的信号槽： 首先定义一个学生类和老师类： 老师类中声明信号 饿了 hungry signals: void hungury(); 学生类中声明槽 请客 treat public slots: ...
【Qt】一篇全面的信号和槽函数机制总结
iriczhao的博客
02-16 1万+
信号和槽函数机制 文章目录信号和槽函数机制一、信号和槽机制简介二、【信号】（2-1）信号的发出（2-2）信号的处理三、【槽函数】（3-1）带有默认参数的信号和槽函数（3-2）使用```QObject::connect()```将信号连接到槽函数。（3-3）信号和槽函数的一些高级用法四、使用Qt与第三方信号和槽函数 一、信号和槽机制简介 ​ （注：下文中的槽与槽函数表示一个意思） ​ 信号和槽用于多个对象之间的通信。信号和槽机制是Qt的核心特性，也是与其他框架最大的不同之处。Qt的元对象系统是信号和槽实现的基
QT学习（2）：信号槽机制
qq_45088122的博客
12-12 855
qt、信号槽机制、观察者模式、链表
QT-02: 深入理解Qt信号与槽机制及实战示例
这种情况下，每当信号被触发，只有这一个槽函数会被调用。这种对应关系是最简单的，它适用于确保特定事件只触发一个特定的响应。 多对一关系： 多对一关系是指多个信号连接到同一个槽函数。在这种情况下，无论哪一...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值