QT实现（4）

最新推荐文章于 2022-05-16 19:39:00 发布
最新推荐文章于 2022-05-16 19:39:00 发布
阅读量927 收藏
点赞数
分类专栏： C++ C++ QT 文章标签： c++ qt 信号机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dayenglish/article/details/23025585
版权
C++ 同时被 2 个专栏收录
34 篇文章 0 订阅
订阅专栏
C++ QT
6 篇文章 0 订阅
订阅专栏 
       err_method_notfound(sender, signal_arg, "connect");
       err_info_about_objects("connect", sender, receiver);
在上面的处理之后，如果不能得到正确的序号，那么编译器就通过上面的函数输出编译信息，提示connec不正确。 
int QMetaObjectPrivate::originalClone(const QMetaObject *mobj, int local_method_index)
{
   int handle = get(mobj)->methodData + 5 * local_method_index;
   while (mobj->d.data[handle + 4] & MethodCloned) {
       handle -= 5;
       local_method_index--;
   }
   return local_method_index;
}

每一个信号和槽函数的相关信息包含五个数字，所以这里的索引值是基位置加上5*索引值，其中以handle为基地址的第四个表示函数的一些属性。这里如果函数的属性是MethodClone则将这个索引减掉。有关信息可以参考QT实现（1）以及qmeta_p.h的相关定义。

static void computeOffsets(const QMetaObject *metaobject, int *signalOffset, int *methodOffset)
{
    *signalOffset = *methodOffset = 0;
    const QMetaObject *m = metaobject->d.superdata;
    while (m) {
        const QMetaObjectPrivate *d = QMetaObjectPrivate::get(m);
        *methodOffset += d->methodCount;
        *signalOffset += (d->revision >= 4) ? d->signalCount : d->methodCount;
        m = m->d.superdata;
    }
}
将所有的信号和槽的偏移累加起来，由于在revision<4的时候，method技术和信号计数是同一个，所以才会有这样的格式。同样的，槽函数的计数实际可以通过method的计数减去信号的计数。由于这里是递加自身以及自身父类的信号和槽的函数技术，所以在QT实现一当中一次递减的是本身所在类的全部的索引。 
int signal_absolute_index = signal_index + methodOffset;
    signal_index += signalOffset;

    QByteArray tmp_method_name;
    int membcode = extract_code(method);
int QMetaObjectPrivate::indexOfSlotRelative(const QMetaObject **m,
                                    const char *slot,
                                    bool normalizeStringData)
{
    return indexOfMethodRelative<MethodSlot>(m, slot, normalizeStringData);
}
这里又转到上面的函数当中，主要还是用于获取索引值。 
QMetaMethod smethod = smeta->method(signal_absolute_index);
QMetaMethod rmethod = rmeta->method(method_index_relative + rmeta->methodOffset());

上面的函数用于创建QMetaMethod类别，QMetaMethod定义在qmetaobject.h当中

QMetaMethod QMetaObject::method(int index) const

{

   int i = index;

   i -= methodOffset();

   if (i < 0 && d.superdata)

       return d.superdata->method(index);

   QMetaMethod result;

   if (i >= 0 && i < priv(d.data)->methodCount) {

       result.mobj = this;

       result.handle = priv(d.data)->methodData + 5*i;

   }

   return result;

}

bool QMetaObjectPrivate ::connect ( const QObject * sender , int signal_index , 
                                 const QObject *receiver, int method_index,
                                 const QMetaObject *rmeta, int type, int *types)
{
    QObject *s = const_cast<QObject *>(sender);
    QObject *r = const_cast<QObject *>(receiver);
    int method_offset = rmeta ? rmeta->methodOffset() : 0;
    QObjectPrivate::StaticMetaCallFunction callFunction =
        (rmeta && QMetaObjectPrivate::get(rmeta)->revision >= 6 && rmeta->d.extradata)
        ? reinterpret_cast<const QMetaObjectExtraData *>(rmeta->d.extradata)->static_metacall : 0;
    QOrderedMutexLocker locker(signalSlotLock(sender),
                               signalSlotLock(receiver));
    if (type & Qt::UniqueConnection) {
        QObjectConnectionListVector *connectionLists = QObjectPrivate::get(s)->connectionLists;
        if (connectionLists && connectionLists->count() > signal_index) {
            const QObjectPrivate::Connection *c2 =
                (*connectionLists)[signal_index].first;
            int method_index_absolute = method_index + method_offset;
            while (c2) {
                if (c2->receiver == receiver && c2->method() == method_index_absolute)
                    return false;
                c2 = c2->nextConnectionList;
            }
        }
        type &= Qt::UniqueConnection - 1;
    }
    QObjectPrivate::Connection *c = new QObjectPrivate::Connection;
    c->sender = s;
    c->receiver = r;
    c->method_relative = method_index;
    c->method_offset = method_offset;
    c->connectionType = type;
    c->argumentTypes = types;
    c->nextConnectionList = 0;
    c->callFunction = callFunction;
    QT_TRY {
        QObjectPrivate::get(s)->addConnection(signal_index, c);
    } QT_CATCH(...) {
        delete c;
        QT_RETHROW;
    }
    c->prev = &(QObjectPrivate::get(r)->senders);
    c->next = *c->prev;
    *c->prev = c;
    if (c->next)
        c->next->prev = &c->next;
    QObjectPrivate *const sender_d = QObjectPrivate::get(s);
    if (signal_index < 0) {
        sender_d->connectedSignals[0] = sender_d->connectedSignals[1] = ~0;
    } else if (signal_index < (int)sizeof(sender_d->connectedSignals) * 8) {
        sender_d->connectedSignals[signal_index >> 5] |= (1 << (signal_index & 0x1f));
    }
    return true;
}

整个connect过程分为四步，第一步根据类型是否是unique检验connect是否是唯一的连接。如果之前已经有连接，那么直接返回false，否则继续。第二步，在当前是unique的情况下之前没有connect或者没有unique要求的时候直接创建connection类别。第三步调用addConnection将刚刚创建的connection加入到链表当中。第四步，设置信号的位图。看起来很复杂的prev和next，实际这里只是单链表的挂在，最后的senders值为C，然后利用八位的位图置信号位。之余Lock是为了在函数跳出的时候自动析构，从而避免使用者忘记解锁。

void QObjectPrivate::addConnection(int signal, Connection *c)

{

   if (!connectionLists)

       connectionLists = new QObjectConnectionListVector();

   if (signal >= connectionLists->count())

       connectionLists->resize(signal + 1);

   ConnectionList &connectionList = (*connectionLists)[signal];

   if (connectionList.last) {

       connectionList.last->nextConnectionList = c;

   } else {

       connectionList.first = c;

   }

   connectionList.last = c;

   cleanConnectionLists();

}

利用尾插法将建立connection链表。然后根据需要清除无效的链表项目，因为QT是可以disconnect的。

void QObjectPrivate::cleanConnectionLists()

{

   if (connectionLists->dirty && !connectionLists->inUse) {

       for (int signal = -1; signal < connectionLists->count(); ++signal) {

           QObjectPrivate::ConnectionList &connectionList =

               (*connectionLists)[signal];

           QObjectPrivate::Connection *last = 0;

           QObjectPrivate::Connection **prev = &connectionList.first;

           QObjectPrivate::Connection *c = *prev;

           while (c) {

               if (c->receiver) {

                   last = c;

                   prev = &c->nextConnectionList;

                   c = *prev;

               } else {

                   QObjectPrivate::Connection *next = c->nextConnectionList;

                   *prev = next;

                   delete c;

                   c = next;

               }

           }

           connectionList.last = last;

       }

       connectionLists->dirty = false;

   }

}

下面列出整个connect函数的实现。通过之前的分析，可以看出整个函数分为三部分，参数验证和相应的参数转化，然后才是真正的实现connect。

bool QObject::connect(const QObject *sender, const char *signal,

                     const QObject *receiver, const char *method,

                     Qt::ConnectionType type)

{

   {

       const void *cbdata[] = { sender, signal, receiver, method, &type };

       if (QInternal::activateCallbacks(QInternal::ConnectCallback, (void **) cbdata))

           return true;

   }

   if (type == Qt::AutoCompatConnection) {

       type = Qt::AutoConnection;

   }

   if (sender == 0 || receiver == 0 || signal == 0 || method == 0) {

       qWarning("QObject::connect: Cannot connect %s::%s to %s::%s",

                sender ? sender->metaObject()->className() : "(null)",

                (signal && *signal) ? signal+1 : "(null)",

                receiver ? receiver->metaObject()->className() : "(null)",

                (method && *method) ? method+1 : "(null)");

       return false;

   }

   QByteArray tmp_signal_name;

   if (!check_signal_macro(sender, signal, "connect", "bind"))

       return false;

   const QMetaObject *smeta = sender->metaObject();

   const char *signal_arg = signal;

   ++signal; //skip code

   int signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, false);

   if (signal_index < 0) {

       // check for normalized signatures

       tmp_signal_name = QMetaObject::normalizedSignature(signal - 1);

       signal = tmp_signal_name.constData() + 1;

       smeta = sender->metaObject();

       signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, false);

   }

   if (signal_index < 0) {

       // re-use tmp_signal_name and signal from above

       smeta = sender->metaObject();

       signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, true);

   }

   if (signal_index < 0) {

       err_method_notfound(sender, signal_arg, "connect");

       err_info_about_objects("connect", sender, receiver);

       return false;

   }

   signal_index = QMetaObjectPrivate::originalClone(smeta, signal_index);

   int signalOffset, methodOffset;

   computeOffsets(smeta, &signalOffset, &methodOffset);

   int signal_absolute_index = signal_index + methodOffset;

   signal_index += signalOffset;

   QByteArray tmp_method_name;

   int membcode = extract_code(method);

   if (!check_method_code(membcode, receiver, method, "connect"))

       return false;

   const char *method_arg = method;

   ++method; // skip code

   const QMetaObject *rmeta = receiver->metaObject();

   int method_index_relative = -1;

   switch (membcode) {

   case QSLOT_CODE:

       method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(&rmeta, method, false);

       break;

   case QSIGNAL_CODE:

       method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(&rmeta, method, false);

       break;

   }

   if (method_index_relative < 0) {

       // check for normalized methods

       tmp_method_name = QMetaObject::normalizedSignature(method);

       method = tmp_method_name.constData();

       // rmeta may have been modified above

       rmeta = receiver->metaObject();

       switch (membcode) {

       case QSLOT_CODE:

           method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(&rmeta, method, false);

           if (method_index_relative < 0)

               method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(&rmeta, method, true);

           break;

       case QSIGNAL_CODE:

           method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(&rmeta, method, false);

           if (method_index_relative < 0)

               method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(&rmeta, method, true);

           break;

       }

   }

   if (method_index_relative < 0) {

       err_method_notfound(receiver, method_arg, "connect");

       err_info_about_objects("connect", sender, receiver);

       return false;

   }

   if (!QMetaObject::checkConnectArgs(signal, method)) {

       qWarning("QObject::connect: Incompatible sender/receiver arguments"

                "\n        %s::%s --> %s::%s",

                sender->metaObject()->className(), signal,

                receiver->metaObject()->className(), method);

       return false;

   }

   int *types = 0;

   if ((type == Qt::QueuedConnection)

           && !(types = queuedConnectionTypes(smeta->method(signal_absolute_index).parameterTypes())))

       return false;

   if (warnCompat) {

       QMetaMethod smethod = smeta->method(signal_absolute_index);

       QMetaMethod rmethod = rmeta->method(method_index_relative + rmeta->methodOffset());

       check_and_warn_compat(smeta, smethod, rmeta, rmethod);

   }

   if (!QMetaObjectPrivate::connect(sender, signal_index, receiver, method_index_relative, rmeta ,type, types))

       return false;

   const_cast<QObject*>(sender)->connectNotify(signal - 1);

   return true;

}


轩动day
关注
专栏目录
Qt MetaObject System详解之五：signal&slot
哇哦~
03-30 495
本篇探析signal slot的连接和调用是如何实现的。宏SLOT，SIGNAL在qobjectdefs.h中有这样的定义：# define METHOD(a)   "0"#a# define SLOT(a)     "1"#a# define SIGNAL(a)   "2"#a不过是在方法签名之前加了一个数字标记。因为我们既可以将signal连接到slot，也可以将signal连接到signal...
读QT5.7源码（七）QMetaObjectPrivate
春暖花开
02-21 1050
QMetaObjectPrivate  提供了对QMetaObject类成员中 uint类型数组的管理，这是个复杂的结构，因此QMetaObjectPrivate提供了结构的定义和操作函数，来方便对其的管理工作。 添加了  classInfo method emum property 后MOC生成的 QMetaObject.data 节 类的声明： class Wid
Qt源码分析之信号和槽机制
oowgsoo的专栏
03-14 2万+
Qt的信号和槽机制是Qt的一大特点,实际上这是和MFC中的消息映射机制相似的东西,要完成的事情也差不多,就是发送一个消息然后让其它窗口响应,当然,这里的消息是广义的说法,简单点说就是如何在一个类的一个函数中触发另一个类的另一个函数调用,而且还要把相关的参数传递过去.好像这和回调函数也有点关系,但是消息机制可比回调函数有用多了,也复杂多了MFC中的消息机制没有采用C++中的虚函数机制,原因是消息
QT信号与槽的原理
weixin_43246170的博客
11-24 1793
本文从源码的角度来分析信号与槽的原理。 首先当我们在头文件中增加了关键字Q_OBJECT后moc工具（meta-object-Compiler元对象编译器）会将根据头文件内容生成一个moc的了文件。 我们还是使用官方的例程进行讲解。 Counter.h #ifndef COUNTER_H #define COUNTER_H #include <QObject> #include <QDebug> class Counter : public QObject { Q_OBJE
QtMetaObjectsysmtem详解之三:QMetaObject接口实现
qq_33663749的博客
11-02 710
本篇从Qt MetaObject源代码解读相关接口的实现，这些接口都定义于qmetaobject.cpp中。 QMetaObject::className() inline const char *QMetaObject::className() const { return d.stringdata; } 从前一篇可知，d.stringdata就是那块字符串数据，包含若干c字符串
windows用QT实现画图工具
06-22
在windows平台下用QT实现的画图工具 可移植 在windows平台下用QT实现的画图工具 可移植 在windows平台下用QT实现的画图工具 可移植 在windows平台下用QT实现的画图工具 可移植 在windows平台下用QT实现的画图工具 可...
opengl+qt实现模型旋转平移
最新发布
06-23
opengl+qt实现模型旋转平移opengl+qt实现模型旋转平移opengl+qt实现模型旋转平移opengl+qt实现模型旋转平移opengl+qt实现模型旋转平移opengl+qt实现模型旋转平移opengl+qt实现模型旋转平移opengl+qt实现模型旋转平移...
Qt实现网络拓扑图
07-15
本文将深入探讨如何利用Qt实现这一功能。 首先，Qt是一个跨平台的应用程序开发框架，它提供了丰富的C++库，用于构建图形用户界面（GUI）和其他桌面应用。Qt中的`QGraphicsView`和`QGraphicsScene`组件是实现网络...
QT实现SSH，sftp
10-20
QT实现SSH和SFTP是基于Qt框架的网络通信技术，主要应用于远程服务器的访问和文件传输。在本文中，我们将深入探讨如何使用QT库来实现SSH（Secure Shell）和SFTP（Secure File Transfer Protocol）功能，以及如何在...
qt 实现Ribbon界面
03-02
在Qt框架中实现Ribbon界面，我们可以利用Qt的可扩展性和自定义部件功能来构建类似于Microsoft Office风格的用户界面。Ribbon界面以其高效的空间利用和直观的布局方式，被广泛应用于许多现代应用软件中，为用户提供了...
Qt信号与槽机制源码分析
www.wowothink.com的专栏
05-28 5890
在前一篇中，我翻译了一篇关于信号与槽机制详解的文章Qt信号与槽工作机制–译文。在这一篇文章中，我将根据自己的理解从Qt源码中分析该机制。建议在看本文章之前先去看看前面提到的译文或者直接看原文原文How Qt Signals and Slots Work。本文只分析了大概的思路，很多细节并没有深究下去，如有错误，敬请大家指正。 以下所有代码的测试基于Qt5.4.0，MOC版本是67。测试代码同样，我
Qt--QObject
HW的博客
11-22 2763
QObject上一节中我们讲了QObject是Qt中使用Meta-Object元对象模型或者说使用信号与槽机制，必须继承的根基类，一般面向对象语言都会有这么一个根基类，提供了语言的基础，那么Qt作为C++的扩展库，QObject作为Qt的根类，为我们提供了哪些功能呢？对象树在Qt的构造函数中，我们可以发现都带有一个QObject* parent=0的默认参数，这个parent就是用来指定父对象QOb
(二)：Qt信号槽连接及触发原理
点点滴滴
11-04 3198
经过《Qt信号槽之—准备阶段》学习，我们知道信号是函数，里面调用了 QMetaObject::activate() 函数； 而对于接收端的槽函数或信号，是通过私有静态函数 qt_static_metacall() 调用元方法。 源头是有的，接收端也是有的，中间少了个桥，这个桥就是 Qt 元对象系统的技术内幕，我们需要阅读 Qt 核心源码才能知道。 后面三个小节就是把从源头到接收端的桥解析一下。 connect做了什么? connect我们都知道是将信号和槽进行关联，具体这个桥梁如何搭建的，咱们下面进行分解。
Qt信号和槽的使用和核心源码分析
独行Freedom的博客
05-16 744
Qt信号和槽的使用和源码分析 最近几天研究了一下信号和槽，总结一下。直接上干货，少写千篇一律的内容。 Qt的信号和槽是解决两个以及多个QObject对象通信的问题，拿A B C三个对象举例，A对象可以自定义信号并且发出信号，B和C对象可以作为观察者监听A的信号。A对象发出信号的时候，B和C的槽函数会被调用。 其中关键的函数是QObject::connect函数和关键字emit。 connect函数 connect函数负责生成被观察者和观察者的连接信息，这些连接信息可以是一对多的，多对多的，多对一的。具体执
Qt的信号和槽是如何工作的
热门推荐
NewThinker_wei 的专栏
04-02 3万+
用Qt做过开发的朋友，不知道是否曾为下面这些问题疑惑过： 我们知道Qt是基于C++的，Qt写的代码最终还是要由C++编译器来编译，但是我们的Qt代码中有很多C++里没有的关键字，比如slots\signals\Q_OBJECT等，为什么C++编译器会放过他们呢？ Qt的槽函数跟普通的成员函数有何区别？一个信号发出后，与之关联的槽函数是什么时候由谁来调用的？ Qt的信号
读QT5.7源码（七）QObjectData 和 QObjectPrivate
春暖花开
02-23 4148
在QObject中定义了一个保护权限的成员变量 d_ptrprotected: QScopedPointer d_ptr; QScopePointer QObject 几乎是所有QT中的类的基类，因此QT中每个继承于Qobject的类都有这个指针，指向一个动态分配的QObjectData对象。 QObjectData类的定义 class Q_CORE_E
Qt 信号槽机制
guochang7511的专栏
04-04 1296
Qt 因其信号槽机制闻名遐迩。但是信号槽是怎样工作的？本文将解释 QObject 和 QMetaObject 的内部实现，以及探索如何在这种机制下实现信号槽。 本文将展示 Qt5 的部分代码，不过有时会为格式化以及简洁性而有所修改。 信号和槽     首先，我们通过    官方示例    回忆下信号槽是如何工作的。  我们的头文件是这样的： Language:  C
Qt源码分析--QObject(1)
exlink2012的专栏
05-16 639
解析了QObject类的构造函数和析构函数，还有deleteLater.
Qt信号槽连接方式源码解读
索命的博客
01-09 1018
连接方式
QT4编程：自制图片浏览器实现详解
在QT4中实现图片浏览器涉及的关键知识点包括： 1. **QT4框架**：QT4是Qt库的一个早期版本，它提供了一个跨平台的开发框架，用于创建图形用户界面（GUI）应用程序。开发者可以使用C++语言进行编程，QT4包含了丰富的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值