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

置顶 已于 2024-03-06 22:53:13 修改
阅读量2.1k 收藏 50
点赞数 57
分类专栏： 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森～
关注
  • 57
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
021 QT信号槽概念原理讲解.7z
10-23
021 QT信号槽概念原理讲解.7z
QT信号槽在哪个线程执行
sundynes 之Hello word
01-18 376
Qt多线程中槽函数在哪个线程里执行分析
Qt 信号和槽执行线程问题
weixin_43820463的博客
09-28 852
QT 槽函数执行线程
qt 多线程编程信号与槽
alex1801
10-20 2175
QThread类提供不依赖于平台的管理线程的方法。一个QThread类的对象管理一个线程，一 般从QThread继承一个自定义类，并重定义虚函数run()，在run()函数里实现线程需要完成的任务。 1、信号与槽的连接方式 信号与槽的连接函数的原型为： bool QObject::connect (const QObject * sender, const char * signal, ...
Qt 信号槽原理 - 多线程时槽函数调用时机
qq_62381297的博客
01-04 1456
Qt 信号槽跨线程时发生了什么？事件循环中发生了什么？通过源码简单了解一下吧
qt， connect参数，Qt::DirectConnection，Qt::QueuedConnection
热门推荐
life_is_too_hard的博客
08-01 4万+
connect用于连接qt的信号和槽，在qt编程过程中不可或缺。它其实有第五个参数，只是一般使用默认值，在满足某些特殊需求的时候可能需要手动设置。 Qt::AutoConnection： 默认值，使用这个值则连接类型会在信号发送时决定。如果接收者和发送者在同一个线程，则自动使用Qt::DirectConnection类型。如果接收者和发送者不在一个线程，则自动使用Qt::QueuedConnec
10 QT - 自定义信号和槽
阿甘兄
10-18 1103
使用connect()可以让我们连接系统提供的信号和槽。但是，Qt 的信号槽机制并不仅仅是使用系统提供的那部分，还会允许我们自己设计自己的信号和槽。 下面我们看看使用 Qt 的信号槽： 首先定义一个学生类和老师类： 老师类中声明信号 饿了 hungry signals: void hungury(); 学生类中声明槽 请客 treat public slots: ...
QT(42)-QT线程-线程调用槽函数
aggie4628的专栏
08-04 2797
当槽函数运行时间比较长时，为了效率，用线程而非主程序调用槽函数。
Qt中槽函数的几种方法
最新发布
2301_80434259的博客
01-29 923
SLOT(pushButton1())`: 接收信号后调用的槽函数，表示调用当前对象的 `pushButton1()` 成员函数。把按钮的objectName，声明为void on_objectName_clicked();第一种已经完成，`ui->pushButton`: 信号发出者，表示界面上的按钮对象。`SIGNAL(clicked(bool))`: 发出的信号，表示按钮被点击。替换为如下代码，然后不需要按前面的操作声明和定义槽函数，直接lambda定义。`this`: 信号接收者，表示当前对象。
Qt中信号和槽的连接方式详解（多线程）
weixin_43672168的博客
07-18 1874
Qt中五种不同的信号和槽连接方式在多线程环境下的应用非常重要。根据不同的需求和场景，选择合适的连接方式能够保证程序的高效运行和数据的安全处理。 1.Qt::AutoConnection 2.Qt::DirectConnection 3.Qt::QueuedConnection 4.Qt::BlockingQueuedConnection 5.Qt::UniqueConnection
Qt信号槽原理
wjfdsklfdkfksd的博客
04-25 1299
所谓信号槽，实际就是观察者模式。当某个事件发生之后，比如，按钮检测到自己被点击了一下，它就会发出一个信号（signal）。这种发出是没有目的的，类似广播。如果有对象对这个信号感兴趣，它就会使用连接（connect）函数，意思是，将想要处理的信号和自己的一个函数（称为槽（slot））绑定来处理这个信号。也就是说，当信号发出时，被连接的槽函数会自动被回调。这就类似观察者模式：当发生了感兴趣的事件，某一个操作就会被自动触发。
Qt信号槽--入门必备
09-01
非常实用的QT入门知识，适合于初学者自学使用
Qt核心机制、Qt元对象系统、Qt信号槽原理
02-27
个人吐血整理，从源码剖析Qt框架，绝对给力！
qt工程调用响应qml信号，触发qml槽函数
12-09
qt工程中引用qml，并能接受qml发出的信号，也能在cpp中发出信号，触发qml中的槽函数。工程中各举了一个简单的例子，代码简洁易懂。
QT-02-qt信号与槽的演示 可运行
10-19
通过举例 说明qt中信号与槽的对应关系（举例说明了槽与信号 一对一 多对一的关系，另外 一对多 多对多同学可以自己试着写一下哦 ） 举例简单明了 可以快速理解槽与信号的关系及用法
Qt多线程中的信号与槽
木子皿--啥都不会的菜鸟
04-15 1496
文章目录1 多线程中的信号与槽 1 多线程中的信号与槽 值得思考的问题： 线程对象是否可以发射信号（signal）？ 是否可以定义槽函数（slot）？ QThread类拥有发射信号和定义槽函数的能力，关键的信号如下： void started()： 线程开始运行时发射该信号。 void finished()： 线程完成运行时发射该信号。 void terminated()： ...
Qt单线程中一个信号绑定多个槽，槽调用时序探索
三千幻想乡
11-20 5091
  信号(signal)与槽(slot)是Qt特有的机制，它可以让控件间的通信变的很方便。你也可以很轻易地使用一个signal绑定多个slot，本文谈一下一个signal绑定多个slot时，slot的执行顺序。 connect函数  signal和slot通过connect连接，继承于QObject的类可以使用这种机制。 [static] QMetaObject::Connection QOb...
学习QT之信号槽机制详解
贝勒里恩的博客
03-05 1605
学习QT之信号槽机制详解 一、Qt信号槽机制 概念：信号槽是Qt框架引以为豪的机制之一。所谓信号槽，实际就是观察者模式。当某个事件发生之后，比如：按钮检测到自己被点击了一下，它就会发出一个信号（signal）。这种发出是没有目的的，类似广播。如果有对象对这个信号感兴趣，他就会使用连接（connect）函数，意思是，将想要处理的信号和自己的一个函数（称为槽（slot））绑定来处理这个信号。也就是说，...
Qt槽函数的几种用法
qq_45076095的博客
03-09 1万+
Qt槽函数的几种用法通过ui控件添加槽函数通过connect连接 通过ui控件添加槽函数 这种方法是在Qt的ui文件中，添加一个控件，然后点击右键，选择具体的槽函数，具体操作如下： 新建一个Qt项目（略过） 点击ui文件 添加一个控件（这里添加一个按钮（PushButton）） 右键按钮控件 选择相应的事件(这里选择clicked) 在mainwindow.h和mainwindow.cpp中会自动添加两段代码，如下： 然后就可以在函数中添加相关代码来实现。 通过connect连接 **1、首先介
qt 如何判断槽函数所在线程
05-18
在 Qt 中，可以通过 `QObject::thread()` 方法来获取一个对象所属的线程。因此，可以在槽函数中通过调用该方法来判断槽函数所在线程。 具体来说，如果当前线程 ID 等于信号发送方所属的线程 ID，则说明槽函数在同一线程中执行；否则，说明槽函数在另一个线程中执行。 示例代码如下： ```cpp void MyClass::mySlot() { if (QThread::currentThreadId() == sender()->thread()->currentThreadId()) { qDebug() << "Slot is executed in the same thread as the signal sender."; } else { qDebug() << "Slot is executed in a different thread than the signal sender."; } } ``` 需要注意的是，如果槽函数执行的时间较长，那么在槽函数执行期间，其所属的线程可能会被阻塞，从而导致其他事件无法得到处理。因此，在实际开发中，应该尽量避免在槽函数中执行耗时操作，以免影响程序的响应性能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值