Qt 信号槽机制解析三 补充解释源代码

本文详细解析了Qt中信号槽机制的工作原理,包括moc工具如何处理信号和槽的声明,以及QMetaObject如何用于实现跨对象之间的信号传递。通过具体的代码示例,展示了信号与槽连接的具体过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

moc生成文件分析:
首先看一下简单含有的signal, slot代码
class myClass : public QObject
{
    Q_OBJECT
public:
    myClass();
    ~myClass();
    void trigger();
    void trigger2();
signals:
    void signalFunc(double);
    int signalFunc2(char, int);
protected slots:
    void slotFunc(double);
    int slotFunc2(char);
};


// 只是实例代码,用来生成moc_myClass
#include”myClass.h”
using std::cout;
using std::endl;
myClass::myClass()
{
    connect(this, SIGNAL(signalFunc),this, SLOT(slotFunc));
    connect(this, SIGNAL(signalFunc2),  this, SLOT(slotFunc2));
}
myClass::~myClass()
{
}
void myClass::slotFunc(double d)
{
    cout << “slotFunc” << endl;
}
int myClass::slotFunc2(char c)
{
    cout << “slotFunc2″ << endl;
    return c;
}
void myClass::trigger()
{
}
void myClass::trigger2()
{
}


编译生成moc_myClass.cpp
static const uint qt_meta_data_myClass[] = {
    // content:
    4, // revision
    0, // classname
    0, 0, // classinfo
    4, 14, // methods
    0, 0, // properties
    0, 0, // enums/sets
    0, 0, // constructors
    0, // flags
    2, // signalCount
    // signals: signature, parameters, type, tag, flags
    9, 8, 8, 8, 0×05,
    34, 32, 28, 8, 0×05,
    // slots: signature, parameters, type, tag, flags
    56, 8, 8, 8, 0×09,
    73, 8, 28, 8, 0×09,
    0 // eod
};

其中methods部分,4代表这个对象含有4个signal + slot, 14是基础数字,在moc代码里面也是硬编码,数一下content的个数,刚好是14,这个14其实就是个偏移量,偏移到signal的第一行.数一下


// content:
4, // revision             0
0, // classname        1
0, 0, // classinfo       2,3
4, 14, // methods     4,5
0, 0, // properties     6,7
0, 0, // enums/sets   8,9
0, 0, // constructors  10,11
0, // flags                    12
2, // signalCount        13
// signals: signature, parameters, type, tag, flags
9, 8, 8, 8, 0×05,         14

signal和slot的flag提供了一些属性,这个会在后面的QObject::connect讲到。
这里需要提出来一点是signal和slot的第一个数值,9, 34, 56, 73这几个,这个马上会讲到先提出来,留个印象

这里前14个数值是对应的QMetaObjectPrivate的值:

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
    …
    …
}

接下来是:
static const char qt_meta_stringdata_myClass[] = {
    “myClass/0/0signalFunc(double)/0int/0,/0″
    “signalFunc2(char,int)/0slotFunc(double)/0″
    “slotFunc2(char)/0″
};
从这个字符串里面,可以看到第一个值为这个类的类名(元对象可以不通过RTTI给出类名的原因就在这里)
在第一个/0后面会给出第一个signal的返回值类型,在这个例子中signalFunc没有返回值,所以没有任何内容,
在第二个/0后面会给出参数名,因为moc读取的是头文件,而我们在头文件中没定义参数名,所以为空
然后就是signal的名字和参数列表类型,这里需要注意的是,即使头文件给出了参数名,在这里也会被忽略掉,只提供类型
再下一个/0后面就是下一个函数的描述了,描述的方式跟前面是一样的。
刚刚提到的9, 34, 56, 73这几个数字,在这里是有用的,这几个数字,刚好是这个字符串对应的函数开头的部分。比如9,那我们在这个字符串中数9个字符,即signalFunc(double)这一段内容。

然后是源对象的数据定义:
const QMetaObject myClass::staticMetaObject = {
    { &QObject::staticMetaObject, qt_meta_stringdata_myClass,
      qt_meta_data_myClass, 0 }
};
可以看到源对象的数据定义为:
struct { // private data
    const QMetaObject *superdata;
    const char *stringdata;
    const uint *data;
    const void *extradata;
}
这个名为staticMetaObject的对象是由Q_OBJECT引入的
第一个数据为父类名字, moc对于多继承的限制可能也在于此。
moc规定多继承的情况下,moc会假设第一个继承的类为QObject, 并且必须要保证在多继承中,只有唯一一个类是继承自QObject的。这样看上去,多余一个QObject继承的,第二个QObject根本没办法识别出来。
第二个数据就是上面的字符串数据
第三个也是上面的uint*数据。
这个源对象非常关键,后面的内容就靠他了。
[cpp] view plaincopyprint?
const QMetaObject &myClass::getStaticMetaObject() { return staticMetaObject; }
const QMetaObject *myClass::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
}
这2个方法都是由Q_OBJECT引入的。目的是返回这个类的元对象


[cpp] view plaincopyprint?
void *myClass::qt_metacast(const char *_clname)
{
if (!_clname) return 0;
if (!strcmp(_clname, qt_meta_stringdata_myClass))
return static_cast(const_cast< myClass*>(this));
return QObject::qt_metacast(_clname);
}
还是由Q_OBJECT引入的

当传入的字符串数据是当前这个类的话,就将this指针转换成void指针传给外界:这个操作相当危险。
如果不是当前类的话,就调用父类的qt_metacast继续查询。
在这里,我的父类是QObject,所以自然就调用QObject::qt_metacase了
在看qt_metacall之前,先看下signal的定义。 额。。事实上signal不需要你自己定义,moc已经帮我们完成这点了。
具体内容如下:
// SIGNAL 0
void myClass::signalFunc(double _t1)
{
void *_a[] = { 0, const_cast(reinterpret_cast(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
我们看到他将所有的参数都转型成void*指针保存到 void *a的数组中,然后调用了
QMetaObject::activate(this, &staticMetaObject, 0, _a);
看到传入的参数为this, 源对象和参数
这个函数实际上就是触发消息的函数,在这里不过多关注他,有机会再写
最终,int myClass::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
会被调用,用来处理对应的signal的消息
代码如下:
int myClass::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: signalFunc((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 1: { int _r = signalFunc2((*reinterpret_cast< char(*)>(_a[1])),(*reinterpret_cast(_a[2])));
            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r; } break;
        case 2: slotFunc((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 3: { int _r = slotFunc2((*reinterpret_cast< char(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r; } break;
        default: ;
        }
        _id -= 4;
    }
    return _id;
}
这里可以注意下,有返回值和没有返回值的处理方法。


QT从.ui文件生成ui_***.h文件 ui文件待解析!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值