QObject

最新推荐文章于 2024-07-15 16:07:27 发布
最新推荐文章于 2024-07-15 16:07:27 发布
阅读量958 收藏 20
点赞数 18
分类专栏： qt 文章标签： qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_33263516/article/details/135233986
版权

QObject

QObject::connect的5种用法

1. 使用SIGNAL()和SLOT()宏（Qt4）

class myobject : public QObject
{
    Q_OBJECT

public:
    myobject(QObject *parent = nullptr):QObject(parent){
    }
signals:
    void signal1(int i);
public slots:
    void slot1(int i){
        qDebug()<<"slot1,i="<<i;
    }
};
#普通函数
void funslot(int i)
{
    qDebug()<<"fun:i="<<i;
}

myobject *obj1 = new  myobject("boj1");
myobject *obj2 = new  myobject("boj2");
QObject::connect(obj1, SIGNAL(signal1(int)), obj2, SLOT(slot1(int)),Qt::AutoConnection);
QObject::connect(obj1, "2signal1(int)", obj2, "1slot1(int)",Qt::AutoConnection);
emit obj1->signal1(123);

注意，信号和槽参数不能包含任何变量名，只能包含类型。名称错误编译阶段无法检测出来
#define SLOT(a) “1”#a
#define SIGNAL(a) “2”#a

最终加入到发送者connect链表里面的连接：
    QMetaObjectPrivate::connect{
    c->method_relative = method_index;
    c->method_offset = method_offset;
    c->connectionType = type;
    c->isSlotObject = false;
    c->argumentTypes.storeRelaxed(types);
    c->callFunction = callFunction;
    }
Connection保存在发送者的SignalVector[signal_index]里面其数据结构层级为：
QObject->QObjectPrivate->ConnectionData->SignalVector->ConnectionList->QObjectPrivate::Connection
SignalVector可以看成是个二维数组[signal_index][ConnectionList]，
signal_index为信号函数对应的编号,其从0开始按照声明顺序递增0，1，2，3，4....
每一次connect就相当于在发送对象的SignalVector[signal_index]新增一个QObjectPrivate::Connection
每次disconnect就相当于在发送对象的SignalVector[signal_index]删除一个或多个匹配的QObjectPrivate::Connection

2. 使用类成员函数指针（Qt5新增，并推荐）

QObject::connect(obj1, &myobject::signal1, obj2, &myobject::slot1,Qt::AutoConnection);
QObject::connect(obj1, &myobject::signal1, &myobject::slot1);
QObject::connect(obj1, &myobject::signal1, funslot);

注意，信号和槽地址错误，编译阶段可以检测出来
有重载的情况怎么办？QOverload或static_cast转换解决
最好的做法可能是建议不要重载信号或槽

QObject::connect(obj1, &myobject::signal1, obj2, QOverload<float>::of(&myobject::slot1),Qt::AutoConnection);
QObject::connect(obj1, &myobject::signal1, static_cast<void (myobject::*)(int)>(&myobject::slot1));

优点

  1. 编译时检查是否存在信号和插槽，类型，或者是否缺少Q_OBJECT。
    （但是如果信号参数填的是非信号函数，编译阶段检查不出来，运行时报错signal not found）
    QObject::connect(obj1, &myobject::slot1, &myobject::slot1);
    //QObject::connect: signal not found
  2. 参数可以通过typedef定义，也可以使用不同的名称空间说明符，并且可以使用。
  3. 如果存在隐式转换（例如，从QString到QVariant），则可以自动转换类型。
  4. 可以连接到QObject的任何成员函数，而不仅仅是插槽。
  5. 可以与C++11 lambda表达式一起使用

缺点

  1. 更复杂的语法（您需要指定对象的类型）
  2. 重载载情况下的语法非常复杂
  3. 不再支持插槽中的默认参数。
最终加入到发送者connect链表里面的连接：
std::unique_ptr<QObjectPrivate::Connection> c{new QObjectPrivate::Connection};
    c->sender = s;
    c->signal_index = signal_index;
    c->receiverThreadData.storeRelaxed(td);
    c->receiver.storeRelaxed(r);
    c->slotObj = slotObj;
    c->connectionType = type;
    c->isSlotObject = true;
    if (types) {
        c->argumentTypes.storeRelaxed(types);
        c->ownArgumentTypes = false;
    }

3. 关联函数

QObject::connect(obj1, &myobject::signal1, funslot);
最终加入到发送者connect链表里面的连接QObjectPrivate::Connection
同使用类成员函数指针

4. Lambda

QObject::connect(obj1, &myobject::signal1, [](int i){
           qDebug()<<"Lambda:i="<<i;
       });
QObject::connect(obj1, &myobject::signal1,obj2, [](int i){
           qDebug()<<"Lambda:i="<<i;
       },Qt::AutoConnection);
最终加入到发送者connect链表里面的连接QObjectPrivate::Connection
同使用类成员函数指针

5. QMetaMethod 很少用到

QMetaMethod sig = obj1->metaObject()->method(obj1->metaObject()->methodOffset()); // void signal1(int i);
QMetaMethod slt = obj2->metaObject()->method(obj2->metaObject()->methodOffset()+1);//void slot1(int i);
QObject::connect(obj1, sig, obj2, slt, Qt::AutoConnection);

可以根据QObject的metaObject()方法获取元对象QMetaObject，然后根据元对象的method方法获取信号或槽的元方法对象QMetaMethod
元对象QMetaObject的methodOffset()函数获取当前对象的第一个信号的位置（不一定为0）,
如果没有信号就是第一个槽的位置，按照信号槽函数的声明顺序来的，信号在前面槽在后面
可以打印出来观看：

    for(int i = obj1->metaObject()->methodOffset(); i < metaObject->methodCount(); ++i)
        qDebug() << QString::fromLatin1(metaObject->method(i).methodSignature());

Qt::ConnectionType

1. Qt::AutoConnection

<(默认)如果接收器位于发出信号的线程中，则使用Qt::DirectConnection。否则，使用Qt::QueuedConnection。在发出信号时确定连接类型。

receiverInSameThread判断发送信号对象和接收的槽对象是否在同一个线程
if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread)
                || (c->connectionType == Qt::QueuedConnection)) 
{
       QMetaCallEvent *ev = new QMetaCallEvent(c->slotObj, sender, signal, nargs);
       QCoreApplication::postEvent(receiver, ev);
 }
 else if (c->connectionType == Qt::BlockingQueuedConnection) 
 {
    //信号量会被放入事件里面，在事件析构的时候release
    QSemaphore semaphore;

    {
       QBasicMutexLocker locker(signalSlotLock(sender));
       QMetaCallEvent *ev = new QMetaCallEvent(c->slotObj, sender, signal_index, argv, &semaphore);
       QCoreApplication::postEvent(receiver, ev);
    }
    semaphore.acquire();
 }else
 {
     QMetaObject::metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv);
 }            

bool QObject::event(QEvent *e)
{
switch (e->type()) {
        case QEvent::MetaCall:
        {
            QAbstractMetaCallEvent *mce = static_cast<QAbstractMetaCallEvent*>(e);
            QBasicMutexLocker locker(signalSlotLock(this));
            mce->placeMetaCall(this);
            break;
        }
}
}

void QMetaCallEvent::placeMetaCall(QObject *object)
{
        QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod,
                              d.method_offset_ + d.method_relative_, d.args_);
}

QAbstractMetaCallEvent::~QAbstractMetaCallEvent()
{
#if QT_CONFIG(thread)
    if (semaphore_)
        semaphore_->release();
#endif
}

2. Qt::DirectConnection

当发出信号时，立即调用该槽。如果槽函数对象与信号不在同一线程，槽函数也会在信号线程中执行。

3. Qt::QueuedConnection

当控制返回到接收者线程的事件循环时调用该槽。槽在接收者的线程中执行。

4. Qt::BlockingQueuedConnection

与Qt::QueuedConnection相同，除了信号线程阻塞直到插槽返回。
如果接收方位于信号线程中，则不能使用此连接，否则应用程序将死锁。

5. Qt::UniqueConnection

这是一个标志，可以使用位或与上述任何一种连接类型组合使用。当Qt::UniqueConnection设置时，如果连接已经存在，QObject::connect()将失败(即，如果相同的信号已经连接到同一插槽的同一对对象)。这个标志是在Qt 4.6中引入的。

信号与槽

1. 信号的定义

使用关键字：signals 加冒号, 后面声明的函数就是信号，其本质就是函数
其被宏定义为：# define signals public qt_signal
信号不需要也不可以由我们自己实现，因为其会被moc编译器编译成函数
*信号与槽的返回值要兼容

signals: //等于 public qt_signal :
    void signal1(int i);
    void signal2(int i);
    void signal3(int i);

moc编译器编译后的myobject::signal1函数，实现如下：
void myobject::signal1(int _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

2. 信号发送

  1. 使用关键字emit，emit是空的宏定义： # define emit
  2. 信号函数调用前加emit,如 emit obj1->signal1(111);
  3. 由于emit是空的宏定义,所以也可以直接调用信号函数,obj1->signal1(111);

信号发送本质就是函数调用
一般为了区分是信号和普通函数，都会加上emit关键字，提高代码可读性

3. 槽函数

  1. 权限声明后加slots表示后面的为槽函数，如public slots:
  2. 槽函数不支持默认参数
class A:public QObject
{
    Q_OBJECT
signals:
int signal2();
public slots:
    int slot1(int i=100);
};
QObject::connect(obj1, &myobject::signal2, obj2, &myobject::slot1,Qt::AutoConnection);//不支持，编译时报错
QObject::connect(obj1, SIGNAL(signal2()),obj2,SLOT(slot1(int)),Qt::AutoConnection);//运行时报错
emit signal2();

disconnect

1. 取消所有信号关联的所有槽

```
QObject::disconnect(obj1, nullptr, nullptr, nullptr);
obj1->disconnect();
这同时也会取消lambda和普通函数的关联
```

2. 取消某个信号关联的所有槽

```
QObject::disconnect(obj1,SIGNAL(signal1()), nullptr, nullptr);
QObject::disconnect(obj1,&myobject::signal1, nullptr, nullptr);
obj1->disconnect(SIGNAL(signal1()));
这同时也会取消lambda和普通函数的关联
```

3. 取消某个信号关联的某个接收者的所有槽

```
QObject::disconnect(obj1,SIGNAL(signal1()), obj2, nullptr);
QObject::disconnect(obj1,&myobject::signal1, obj2, nullptr);
这个无法取消lambda和普通函数的关联(普通函数接收者为发送者本身)
QObject::disconnect(obj1,&myobject::signal1, obj1, nullptr);
这个可以取消lambda和普通函数的关联
```

4. 取消某个信号关联的某个接收者的某个槽

如果多个相同的关联都将被取消；
对于这种指定具体的信号和槽的关联取消：SIGNAL/SLOT关联的，必须SIGNAL/SLOT方式取消关联，类成员函数关联的比类成员函数取消关联
```
QObject::connect(obj1,SIGNAL(signal1(int)), obj2, SLOT(slot1(int)));
QObject::disconnect(obj1,SIGNAL(signal1(int)), obj2, SLOT(slot1(int)));

QObject::connect(obj1, &myobject::signal1, obj2, &myobject::slot1);
QObject::disconnect(obj1, &myobject::signal1, obj2, &myobject::slot1);
下面的将无法被取消：
QObject::connect(obj1,SIGNAL(signal1(int)), obj2, SLOT(slot1(int)));
QObject::disconnect(obj1, &myobject::signal1, obj2, &myobject::slot1);
下面的将无法被取消：
QObject::connect(obj1, &myobject::signal1, obj2, &myobject::slot1);
QObject::disconnect(obj1,SIGNAL(signal1(int)), obj2, SLOT(slot1(int)));

具体原因如下：
就是这两种不同方法添加的QObjectPrivate::Connection不一样，具体到槽的匹配永远无法找不到。
disconnect最终都将走到这一步进行匹配：
 if (signal_index < 0) {//如果disconnect传入的signal为nullptr，删除所有信号的所有连接者
        for (int sig_index = -1; sig_index < scd->signalVectorCount(); ++sig_index) {
            disconnectHelper(..., signal_index, receiver, method_index, slot, ...)； 
        }
}else
{
     disconnectHelper(..., signal_index, receiver, method_index, slot, ...)； 
}
disconnectHelper实现如下
auto &connectionList = connections->connectionsForSignal(signal_index);//取出对应信号的连接链表
auto *c = connectionList.first.loadRelaxed();
while (c) { //遍历signal_index信号链表的所有接收者
    QObject *r = c->receiver.loadRelaxed();//获取当前链表节点的接收者
    if (r)
    {
        if(receiver == nullptr ){//如果disconnect传入的接收者为nullptr，直接删除连接者
                connections->removeConnection(c);
        }
        else if(r == receiver)//如果不为空判断连接者是否相同
        {
            //使用类成员函数指针connect的method_index<0,并且是isSlotObject=true
            //使用SIGNAL()和SLOT()宏connect的method_index>0,并且是isSlotObject=false
            if((method_index < 0 || (!c->isSlotObject && c->method() == method_index))
            {
                if((slot == nullptr || (c->isSlotObject && c->slotObj->compare(slot))
                {
                    connections->removeConnection(c);
                }	
            }
            //上面的判断总结为：
            //如果	使用类成员函数指针connect的比较	c->slotObj->compare(slot）
            //如果	使用SIGNAL方式connect的比较c->method() == method_index
            //所以这两种不同的connect，disconnect时具体到槽的匹配永远无法找不到。
        }
    }
    c = c->nextConnectionList.loadRelaxed();
}
```

5. 单独取消关联的某个普通函数和Lambda表达式

使用连接时返回的QMetaObject::Connection变量，取消关联对应连接
```
auto func =QObject::connect(obj1,&myobject::signal1,funslot);
QMetaObject::Connection lambdac = QObject::connect(obj1,&myobject::signal1,[](int a){
  qDebug("lambda %d\n",a);
});
 QObject::disconnect(func);
 QObject::disconnect(lambdac);
```

6. 取消某个接收者对象的所有关联槽

```
QObject::disconnect(obj1, nullptr,obj2, nullptr);
obj1->disconnect(obj2);
```
在黎明的反思
关注
专栏目录
QT QObject分析
gd_mkhu的博客
06-14 706
QT QObject分析 看了上面大佬写的东西，自己也总结一下吧，元对象系统中实现了很多功能，有信号槽机制，将信号，槽，qt 的一些宏转化为 moc_*.h文件，而且其中的信号和槽连接，是通过字符串连接的，然后通过存储的数据，在函数中判断所类型，和取得的序列号，然后通过switch case到达相应的槽。 值得注意的点： 而槽所对应的参数比信号要少，会自动获得较少的。 对于sender()...
Qt 多线程采用继承QObject方式编写
03-18
Qt提供了一种独特的方式来处理多线程，即通过继承`QObject`类来实现。这种方式既方便又安全，因为它允许我们在子线程中使用信号和槽机制，这是Qt的核心特性之一。 首先，理解`QObject`在多线程中的作用。`QObject`...
Qt6.5类库详解：QObject
天恩软件工作室
12-10 1169
详细介绍QObject类的信号，属性，事件处理，事件过滤器和基本函数的使用；重点介绍了Qt信号与槽机制，示例代码演示connect连接函数的使用，和第五个参数类型；最后完整代演示QObject内置定时器的使用。
QObject 详解
热门推荐
beibeix2015的博客
03-16 1万+
QObject描述 1、QObject类是所有Qt对象的基类。 2、QObject是Qt对象模型的核心。该模型的核心特性是一种非常强大的无缝对象通信机制，称为信号和槽。可以使用connect()将信号连接到槽，并使用disconnect()销毁连接。为了避免永无止境的通知循环，可以使用blockSignals()临时阻止信号。受保护的函数connectNotify()和disconnectNotify()使跟踪连接成为可能。 3、对象通过对象树的形式组织。当创建一个以另一个对象为父对象的QObject
QObject学习
Sputnik_02的博客
05-27 1287
做一下QObject的相关笔记，准备来一个系统性的学习。 以下内容全部是个人理解，有谬误的地方欢迎大佬指出！ QObject的成员变量 首先，我们先看一下QObject的大小： qDebug()<<sizeof(QObject); 结果输出为8，我们打开QObject的源码，可以发现这8个字节是类的虚表指针和一个指针成员变量 QScopedPointer<QObjectData> d_ptr; 点开定义发现QScopedPointer是一个模板类，内部...
QT 利用继承Qobject实现多线程
06-01
在QT中，通过继承`QObject`类并利用`moveToThread()`函数，我们可以方便地实现多线程操作，这对于处理耗时任务或避免阻塞主线程来说至关重要。下面我们将深入探讨如何使用这些技术以及`QMutex`来确保线程安全。 ...
QObject-开源
05-14
【标题】"QObject-开源" 描述了一个名为 "QObject" 的 PHP 类库，它专注于数据库管理和数据存储。这个工具的设计目标是将数据库操作这一繁琐任务从开发者的工作中解脱出来，以便他们可以更专注于核心业务逻辑和创新...
Python-一个不带QObject依赖的Qt信号系统的纯Python实现
08-10
标题中的“Python-一个不带QObject依赖的Qt信号系统的纯Python实现”指的是在Python中创建一个与Qt库的QObject类不直接关联的信号系统。在Qt框架中，QObject类是事件驱动模型的基础，它提供了信号（Signals）和槽...
实现QObject与JavaScript通讯
02-28
在Qt框架中，结合QWebEngine和QWebChannel技术，我们可以实现QObject与JavaScript之间的通信，这对于构建富客户端应用或者在Web环境中使用C++组件时非常有用。本文将深入探讨这一主题，详细介绍如何设置和实现这样的...
qt 创建一个矩形，矩形的边线可以拖拽
xie__jin__cheng的博客
07-15 249
qt 创建一个矩形，矩形的边线可以拖拽
QT creator简介
weixin_74923758的博客
07-14 917
轻量级跨平台集成开发环境，包含高级C++代码编辑器、集成的GUI外观和版式设计器、项目和生成管理工具、集成的上下文相关帮助系统以及图形化调试器等。强大的拖曳式图形化用户界面排版和设计工具。：多国语言翻译工具，用于Qt应用程序的多国语言翻译。：基于Qt的开源帮助文档阅读器，用于阅读由Qt Assistant应用程序生成的帮助文件。：用于编译ui文件的命令行工具，全称为UI Compiler。：全称为User Interface Compiler，将.ui文件编译为.h文件的命令行工具。
qt tabWidget 详解
xie__jin__cheng的博客
07-14 699
qt tabWidget 详解
MSVC2017+Qt 打包
SHNIXU的博客
07-15 237
msvcp140.dll
QT5_C++基础
qq_45956475的博客
07-14 466
C++的类是一种构造类型，与C语言的结构体类似，但是进行了一些拓展，类的成员不但可以是变量，还可以是函数；通过类定义出来的变量也有特定的称呼，叫做“对象”类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量，创建对象的过程也叫做类的实例化。
C++客户端Qt开发——QT初识
m0_63596031的博客
07-13 834
②中的代码创建，是在堆上new出来的一块空间，当把对象改成在栈上创建，此时就可以看到运行起来的程序无法显示出helloworld，此时label对象随着构造函数的结束，就销毁了，所以应该把它交给对象树进行管理。在QT Designer中创建一个控件的时候，此时会给这个控件分配一个objectName属性，这个属性的值，要求是在界面中是唯一的，不能和别人重复。Qt的对象树模型是一种递归的结构，其中一个对象可以拥有多个子对象，而每个子对象又可以拥有自己的子对象，以此类推。坐标体系：以左上角为原点（0,0），
vs2017/2019串口Qt Serial Port/modbus使用报错
Txwtech笛克特科
07-13 332
0QModbusTcpClient@@QEAA@PEAVQObject@@@Z)，函数 "public: void __cdecl TcpClientModbus::Connect(class QString,class QString)" (?Connect@TcpClientModbus@@QEAAXVQString@@0@Z) 中引用了该符号 auto_pack_line_demo D:\QT_Project_vs\xx\xx\TcpClientModbus.obj 1。
【Qt】探索Qt框架：开发经典贪吃蛇游戏的全过程与实践
最新发布
Colorful___的博客
07-15 1058
QWidget: 作为大多数Qt控件的基类，QWidget代表了一个窗口或窗口内部的一个区域，可以包含其他控件和进行绘图。: 表示主窗口，是大多数应用程序的顶层窗口。QDialog: 用于创建对话框，用于用户交互。: 用于创建按钮控件，用户可以点击触发事件。在代码中，按钮用于开始游戏、选择游戏难度、返回主界面等操作。QPainter: 用于绘制图形界面的2D图形类。在paintEvent函数中使用，用于绘制游戏界面、蛇的身体、食物等。QIcon: 用于创建和处理图标，设置应用程序或控件的图标。
qt 开发一个可以拖动的矩形
xie__jin__cheng的博客
07-12 396
qt 开发一个可以拖动的矩形
Qt QObject
09-05
Qt QObject 是 Qt 库中的一个基础类。它是所有 Qt 对象的基类，提供了许多基本的对象管理功能，包括内存管理、事件通信、信号和槽机制以及属性系统。 使用 QObject 的子类可以很容易地在应用程序中实现事件驱动的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值