信号槽细节

最新推荐文章于 2022-11-16 17:00:20 发布

原创最新推荐文章于 2022-11-16 17:00:20 发布 · 1.4k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#signal #qt #数据结构 #struct #代码分析

QT 专栏收录该内容

7 篇文章

订阅专栏

本文详细解析了Qt信号槽机制的工作原理，包括如何确定信号发送方与接收方、如何匹配信号与槽函数以及如何传递参数等内容。

(1)Reciver对象可能有多个方法，qt如何知道要调用哪个函数详解

我们从QMetaObjectPrivate::connect(sender, signal_index, receiver, method_index, type, types)

函数入手。sender, receiver是外部传入的参数,signal_index, method_index是两个int。signal,method是字符串。QObject::connect(s,SIGNAL(send(int)),r1,SLOT(count(int)))中，SIGNAL(send(int))产生signal,内容为 "send(int)", SLOT(count(int))产生method，内容为 "1count(int)"。Connect函数中，先得到sender的元对象smeta = sender->metaObject(),然后通过这个函数 int signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal)，得到send(int)方法在元对象smeta中的索引值。通过rmeta = receiver->metaObject()得到元对象，method_index = rmeta->indexOfSlot(method);在receiver的元对象中找到"coun(int)"对应的函数的索引。知道了sender对象且知道要调用其函数的索引,知道了receiver对象且知道要调用其函数的索引，将四者连在一起。当触发sender的signal_index对应的函数时，调用已

连在一起的receiver的method_index对应的函数。

下面是具体的代码分析

QObject::connect(s,SIGNAL(send(int)),r1,SLOT(count(int)));  
bool QObject::connect(const QObject *sender, const char *signal,
                      const QObject *receiver, const char *method,
                      Qt::ConnectionType type)
{
//................................................
//<section1>
    const QMetaObject *smeta = sender->metaObject();
    const char *signal_arg = signal;
    ++signal; //skip code
int signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal);
//</section1>
//................................................
//<section2>
    const QMetaObject *rmeta = receiver->metaObject();
    int method_index = -1;
    switch (membcode) {
    case QSLOT_CODE:
        method_index = rmeta->indexOfSlot(method);
        break;
    case QSIGNAL_CODE:
        method_index = rmeta->indexOfSignal(method);
        break;
    }
//</section2>
//.............................................
//<section3>
 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;
    }
//</section3>
//..............................................
//<section4>
    if (!QMetaObjectPrivate::connect(sender, signal_index, receiver, method_index, type, types))
        return false;
//</section4>
    const_cast<QObject*>(sender)->connectNotify(signal - 1);
    return true;
}

在此文中，sender对象是Informer的对象.receiver对象是Receiver的对象。

在section1中,const QMetaObject *smeta = sender->metaObject();得到了sender的元对象。这个元对象定义在.moc文件中。在Informer类中,有一个Q_OBJECT宏

class Informer:public QObject

{

Q_OBJECT;

//.....................

};

其中有个数据成员

static const QMetaObject staticMetaObject;

还有获得这个元对象的函数

virtual const QMetaObject *metaObject() const; \

在.moc文件中实现了它们

//<code_1>

const QMetaObject Informer::staticMetaObject = {

{ &QObject::staticMetaObject, qt_meta_stringdata_Informer,

qt_meta_data_Informer, 0 }

};

//</code_1>

const QMetaObject *Informer::metaObject() const

{

return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;

}

sender->metaObject()便得到了QMetaObject对象。

重要代码

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

函数indexOfSignalRelative从sender对象的元对象中查找signal，即字符串"send(int)"对应的索引值。先看一下QMetaObjectPrivate的数据结构

//<code_2>
struct QMetaObjectPrivate
{
    int revision;
    int className;
    int classInfoCount, classInfoData;
    int methodCount, methodData;
    int propertyCount, propertyData;
    int enumeratorCount, enumeratorData;
    int constructorCount, constructorData; //since revision 2
    int flags; //since revision 3
int signalCount; //since revision 4
}
//</code_2>

对比一下.moc文件中的qt_meta_data_Informer数组

//<code_3>
static const uint qt_meta_data_Informer[] = {
 // content:
       4,       // revision  //0
       0,       // classname
       0,    0, // classinfo //2
       1,   14, // methods//4
       0,    0, // properties//6
       0,    0, // enums/sets//8
       0,    0, // constructors//10
       0,       // flags//12
       1,       // signalCount//13
 // signals: signature, parameters, type, tag, flags
      17,   10,    9,    9, 0x05, //14
       0        // eod
};
//</code_3>

发现qt_meta_data_Informer前14个字段对应QMetaObjectPrivate数据结构中的字段。能不能由qt_meta_data_Informer得到QMetaObjectPrivate对象呢。是可以的。见Qt的函数priv,代码如下

static inline const QMetaObjectPrivate *priv(const uint* data)

{ return reinterpret_cast<const QMetaObjectPrivate*>(data); }

这样便得到了QMetaObjectPrivate对象。

我们回过头来看indexOfSignalRelative函数，代码如下

int QMetaObjectPrivate::indexOfSignalRelative(const QMetaObject **baseObject, const char *signal)
{
    int i = -1;
    while (*baseObject) {
        const QMetaObject *const m = *baseObject;
        for (i = priv(m->d.data)->methodCount-1; i >= 0; --i)
            if ((m->d.data[priv(m->d.data)->methodData + 5*i + 4] & MethodTypeMask) == MethodSignal
                && strcmp(signal, m->d.stringdata
                + m->d.data[priv(m->d.data)->methodData + 5*i]) == 0) {
                break;
            }
        if (i >= 0)
            break;
        *baseObject = m->d.superdata;
}
//......................................
}

QMetaObject的数据结构如下

struct QMetaObject
{
    struct { // private data
        const QMetaObject *superdata;
        const char *stringdata;
        const uint *data;
        const void *extradata;
} d;
}

m->d.data是const uint *data。m->d.data保存了qt_meta_data_Informer静态数组的指针，见code_1。priv(m->d.data)将qt_meta_data_Informer转化成QMetaObjectPrivate数据类型。很明显，priv(m->d.data)->methodCount为14, 则priv(m->d.data)->methodData + 5*i + 4 = 18, m->d.data[priv(m->d.data)->methodData + 5*i + 4] = m->d.data[18], m->d.tata[18]为0x05, MethodTypeMask = 0x0c, 0x05 & 0x0c = 0x04 == MethodSignal。

这段代码(m->d.data[priv(m->d.data)->methodData + 5*i + 4] & MethodTypeMask) == MethodSignal，判断从元对象而来的函数是不是Signal,因为元对象的方法也可能是Slot

strcmp(signal, m->d.stringdata

+ m->d.data[priv(m->d.data)->methodData + 5*i])

priv(m->d.data)->methodData + 5*i = 14

d.data[14]为17

m->d.stringdata+ m->d.data[priv(m->d.data)->methodData + 5*i] = m->d.stringdata+17

strcmp(signal, m->d.stringdata+17)

Signal为"send(int)", m->d.stringdata为 "Informer",看一下.moc文件中有如下代码

static const char qt_meta_stringdata_Informer[] = {

"Informer\0\0status\0send(int)\0"

};

而 m->d.stringdata在IDE中显示为 "Informer",这是因为\0的原因。

我们看下m->d.stringdata内存，如下

查一下"Informer..status."刚好17位, m->d.stringdata+17正好移动到"send(int)"起始处。这回就明白了qt_meta_data_Informer中17的原因了。

(2)如何将参数传给reciver对应的函数

这个问题就简单了。看<section3>函数checkConnectArgs。这个函数很简单，就是检查const char *signal, const char *method参数是否一样。就是简单的字符串比较

代码如下

/*!
    Returns true if the \a signal and \a method arguments are
    compatible; otherwise returns false.
    Both \a signal and \a method are expected to be normalized.
    \sa normalizedSignature()
*/
bool QMetaObject::checkConnectArgs(const char *signal, const char *method)
{
    const char *s1 = signal;
    const char *s2 = method;
    while (*s1++ != '(') { }                        // scan to first '('
    while (*s2++ != '(') { }
    if (*s2 == ')' || qstrcmp(s1,s2) == 0)        // method has no args or
        return true;                                //   exact match
    int s1len = qstrlen(s1);
    int s2len = qstrlen(s2);
    if (s2len < s1len && strncmp(s1,s2,s2len-1)==0 && s1[s2len-1]==',')
        return true;                                // method has less args
    return false;
}

参数类型一样后，在信号发送端,所有参数强转成void * [], 储存在void **argv中，在接受端强转成对应参数既可。

代码如下

// SIGNAL 0
void Informer::send(int _t1)
{
    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
int Receiver::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) {
        switch (_id) {
        case 0: count((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
        _id -= 1;
    }
    return _id;
}

本文分析了Qt信号槽机制脉络，更具体的细节就不分析了。至此完成了此机制的分析。