Qt moc文件的作用

前面我们说过，Qt 不是使用的“标准的” C++ 语言，而是对其进行了一定程度的“扩展”。这里我们从Qt新增加的关键字就可以看出来：signals、slots 或者 emit。所以有人会觉得 Qt 的程序编译速度慢，这主要是因为在 Qt 将源代码交给标准 C++ 编译器，如 gcc 之前，需要事先将这些扩展的语法去除掉。完成这一操作的就是 moc。

moc 全称是 Meta-Object Compiler，也就是“元对象编译器”。Qt 程序在交由标准编译器编译之前，先要使用 moc 分析 C++ 源文件。如果它发现在一个头文件中包含了宏 Q_OBJECT，则会生成另外一个 C++ 源文件。这个源文件中包含了 Q_OBJECT 宏的实现代码。这个新的文件名字将会是原文件名前面加上 moc_ 构成。这个新的文件同样将进入编译系统，最终被链接到二进制代码中去。因此我们可以知道，这个新的文件不是“替换”掉旧的文件，而是与原文件一起参与编译。另外，我们还可以看出一点，moc 的执行是在预处理器之前。因为预处理器执行之后，Q_OBJECT 宏就不存在了。

既然每个源文件都需要 moc 去处理，那么我们在什么时候调用了它呢？实际上，如果你使用 qmake 的话，这一步调用会在生成的 makefile 中展现出来。从本质上来说，qmake 不过是一个 makefile 生成器，因此，最终执行还是通过 make 完成的。

为了查看 moc 生成的文件，我们使用一个很简单的 cpp 来测试：

test.cpp

class Test : public QObject
{
 Q_OBJECT
public:
 explicit Test(QObject *parent = 0);
signals:
public slots:
};

这是一个空白的类，什么都没有实现。在经过编译之后，我们会在输出文件夹中找到 moc_test.cpp：

moc_test.cpp

/****************************************************************************
** Meta object code from reading C++ file 'test.h'
**
** Created: Thu Jul 22 13:06:45 2010
**      by: The Qt Meta Object Compiler version 62 (Qt 4.6.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../test.h"
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'test.h' doesn't include ."
#elif Q_MOC_OUTPUT_REVISION != 62
#error "This file was generated using the moc from 4.6.3. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
static const uint qt_meta_data_Test[] = {

 // content:
       4,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

static const char qt_meta_stringdata_Test[] = {
    "Test\0"
};

const QMetaObject Test::staticMetaObject = {
    { &QObject::staticMetaObject, qt_meta_stringdata_Test,
      qt_meta_data_Test, 0 }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Test::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

const QMetaObject *Test::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
}

void *Test::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Test))
        return static_cast<void*>(const_cast< Test*>(this));
    return QObject::qt_metacast(_clname);
}

int Test::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
QT_END_MOC_NAMESPACE

可以看到，moc_test.cpp 里面为 Test 类增加了很多函数。然而，我们并没有实际写出这些函数，它是怎么加入类的呢？别忘了，我们还有 Q_OBJECT 这个宏呢！在 qobjectdefs.h 里面，找到 Q_OBJECT 宏的定义：

#define Q_OBJECT \
public: \
    Q_OBJECT_CHECK \
    static const QMetaObject staticMetaObject; \
    Q_OBJECT_GETSTATICMETAOBJECT \
    virtual const QMetaObject *metaObject() const; \
    virtual void *qt_metacast(const char *); \
    QT_TR_FUNCTIONS \
    virtual int qt_metacall(QMetaObject::Call, int, void **); \
private:

这下了解了：正是对 Q_OBJECT 宏的展开，使我们的 Test 类拥有了这些多出来的属性和函数。注意，QT_TR_FUNCTIONS 这个宏也是在这里定义的。也就是说，如果你要使用 tr() 国际化，就必须使用 Q_OBJECT 宏，否则是没有 tr() 函数的。这期间最重要的就是 virtual const QMetaObject *metaObject() const; 函数。这个函数返回 QMetaObject 元对象类的实例，通过它，你就获得了 Qt 类的反射的能力：获取本对象的类型之类，而这一切，都不需要 C++ 编译器的 RTTI 支持。Qt 也提供了一个类似 C++ 的 dynamic_cast() 的函数 qobject_case()，而这一函数的实现也不需要 RTTI。另外，一个没有定义 Q_OBJECT 宏的类与它最接近的父类是同一类型的。也就是说，如果 A 继承了 QObject 并且定义了 Q_OBJECT，B 继承了 A 但没有定义 Q_OBJECT，C 继承了 B，则 C 的 QMetaObject::className() 函数将返回 A，而不是本身的名字。因此，为了避免这一问题，所有继承了 QObject 的类都应该定义 Q_OBJECT 宏，不管你是不是使用信号槽。

以上内容转载自：http://devbean.blog.51cto.com/448512/355100

首先看一下简单含有的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"
 #include
 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, 0x05,
       34,   32,   28,    8, 0x05,
  // slots: signature, parameters, type, tag, flags
       56,    8,    8,    8, 0x09,
       73,    8,   28,    8, 0x09,
        0        // eod
 };

 

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

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*数据。

这个源对象非常关键，后面的内容就靠他了。

 const QMetaObject &myClass::getStaticMetaObject() { return staticMetaObject; }
 const QMetaObject *myClass::metaObject() const
 {
     return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
 }

这2个方法都是由Q_OBJECT引入的。目的是返回这个类的元对象

 void *myClass::qt_metacast(const char *_clname)
 {
     if (!_clname) return 0;
     if (!strcmp(_clname, qt_meta_stringdata_myClass))
         return static_cast<void*>(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<void*>(reinterpret_cast<const void*>(&_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< int(*)>(_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;
 }

 

这里可以注意下，有返回值和没有返回值的处理方法~

moc所作的这些工作，都是为了元对象能更好的工作而做的准备

以上内容转载自： http://blog.csdn.net/liuysheng/article/details/6822718