读QT5.7源码（三）Q_OBJECT 和QMetaObject

Qt meta-object系统基于三个方面：
  1、QObject提供一个基类，方便派生类使用meta-object系统的功能；
  2、Q_OBJECT宏，在类的声明体内激活meta-object功能，比如动态属性、信号、槽；
  3、Meta Object编译器（MOC），为每个QObject派生类生成代码，以支持meta-object功能。

QObject定义了从一个QObject对象访问meta-object功能的接口，Q_OBJECT宏用来告诉编译器该类需要激活meta- object功能，编译器在扫描一个源文件时，如果发现类的声明中有这个宏，就会生成一些代码来为支持meta-object功能——主要是生成该类对应 MetaObject类以及对QObject的函数override。

QObject和QMetaObject：

顾名思义，QMetaObject包含了QObject的所谓的元数据，也就是QObject信息的一些描述信息：除了类型信息外，还包含QT中特 有的signal&slot信息。
 QObject::metaObject ()方法返回一个QObject对象对应的metaobject对象，注意这个方法是virtual方法。如上文所说，如果一个类的声明中包含了 Q_OBJECT宏，编译器会生成代码来实现这个类对应的QMetaObject类，并重载QObject：：metaObject（）方法来返回这个 QMetaObject类的实例引用。这样当通过QObject类型的引用调用metaObejct方法时，返回的是这个引用的所指的真实对象的 metaobject。

如果一个类从QObject派生，确没有声明Q_OBJECT宏，那么这个类的metaobject对象不会被生成，这样这个类所声明的 signal slot都不能使用，而这个类实例调用metaObject（）返回的就是其父类的metaobject对象，这样导致的后果就是你从这个类实例获得的元 数据其实都是父类的数据，这显然给你的代码埋下隐患。因此如果一个类从QOBject派生，它都应该声明Q_OBJECT宏，不管这个类有没有定义 signal&slot和Property。

这样每个QObject类都有一个对应的QMetaObject类，形成一个平行的类型层次。

QMetaObject提供的信息：

下面通过QMetaObject的接口来解读QMetaObject提供的信息：
1、基本信息
     const char * className () const；
     const QMetaObject * superClass () const
2、classinfo： 提供额外的类信息。其实就是一些名值对。 用户可以在类的声明中以Q_CLASSINFO(name, value)方式添加。
      int classInfoCount () const
      int classInfoOffset () const
      QMetaClassInfo classInfo ( int index ) const
      int indexOfClassInfo ( const char * name ) const
3、contructor：提供该类的构造方法信息
     QMetaMethod constructor ( int index ) const
     int constructorCount () const
     int indexOfConstructor ( const char * constructor ) const
4、enum：描述该类声明体中所包含的枚举类型信息
    QMetaEnum enumerator ( int index ) const
    int enumeratorCount () const
    int enumeratorOffset () const
    int indexOfEnumerator ( const char * name ) const
5、method：描述类中所包含方法信息：包括property,signal,slot等，包括祖先类，如何组织暂时不确定。
    QMetaMethod method ( int index ) const
    int methodCount () const
    int methodOffset () const
    int indexOfMethod ( const char * method ) const
    int indexOfSignal ( const char * signal ) const
    int indexOfSlot ( const char * slot ) const
6、property：类型的属性信息
     QMetaProperty property ( int index ) const
     int propertyCount () const
     int propertyOffset () const
     int indexOfProperty ( const char * name ) const
     QMetaProperty userProperty () const  //返回类中设置了USER flag的属性，（难道只能有一个这样的属性？）

注意：对于类里面定义的函数，构造函数，枚举，只有加上一些宏才表示你希望为方法提供meta信息。比如 Q_ENUMS用来注册宏，

Q_INVACABLE用来注册方法（包括构造函数）。Qt这么设计的原因应该是避免meta信息的臃肿。

下面是Q_OBJECT的宏定义

#define Q_OBJECT \
public: \
    Q_OBJECT_CHECK \
    QT_WARNING_PUSH \
    Q_OBJECT_NO_OVERRIDE_WARNING \
    static const QMetaObject staticMetaObject; \
    virtual const QMetaObject *metaObject() const; \
    virtual void *qt_metacast(const char *); \
    virtual int qt_metacall(QMetaObject::Call, int, void **); \
    QT_TR_FUNCTIONS \
private: \
    Q_OBJECT_NO_ATTRIBUTES_WARNING \
    Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); \
    QT_WARNING_POP \
    struct QPrivateSignal {}; \
    QT_ANNOTATE_CLASS(qt_qobject, "")

因此：

每一个定义了Q_OBJECT宏的，直接或者间接继承于QObject的类 有包含一个名为staticMetaObject的静态QMetaObject对象， 一个私有的静态函数qt_static_metacall。

它们为该类型的所有对象共有，同时它也继承了每一个祖父对象这两个静态成员和函数。

virtual const QMetaObject *metaObject() const; \    用于获取类静态拥有的元对象
    virtual void *qt_metacast(const char *); \                   通过元对象获取对象指针
    virtual int qt_metacall(QMetaObject::Call, int, void **); \     用于信号槽机制

每个不同的类 在MOC生成代码的时候会重写写这些虚函数。

QMetaObjectl类的定义

struct Q_CORE_EXPORT QMetaObject
{
    class Connection;
    const char *className() const;
    const QMetaObject *superClass() const;

    bool inherits(const QMetaObject *metaObject) const Q_DECL_NOEXCEPT;
    QObject *cast(QObject *obj) const;
    const QObject *cast(const QObject *obj) const;

#ifndef QT_NO_TRANSLATION
    QString tr(const char *s, const char *c, int n = -) const;
#endif // QT_NO_TRANSLATION

    int methodOffset() const;
    int enumeratorOffset() const;
    int propertyOffset() const;
    int classInfoOffset() const;

    int constructorCount() const;
    int methodCount() const;
    int enumeratorCount() const;
    int propertyCount() const;
    int classInfoCount() const;

    int indexOfConstructor(const char *constructor) const;
    int indexOfMethod(const char *method) const;
    int indexOfSignal(const char *signal) const;
    int indexOfSlot(const char *slot) const;
    int indexOfEnumerator(const char *name) const;
    int indexOfProperty(const char *name) const;
    int indexOfClassInfo(const char *name) const;

    QMetaMethod constructor(int index) const;
    QMetaMethod method(int index) const;
    QMetaEnum enumerator(int index) const;
    QMetaProperty property(int index) const;
    QMetaClassInfo classInfo(int index) const;
    QMetaProperty userProperty() const;

    static bool checkConnectArgs(const char *signal, const char *method);
    static bool checkConnectArgs(const QMetaMethod &signal,
                                 const QMetaMethod &method);
    static QByteArray normalizedSignature(const char *method);
    static QByteArray normalizedType(const char *type);

    // internal index-based connect
    static Connection connect(const QObject *sender, int signal_index,
                        const QObject *receiver, int method_index,
                        int type = , int *types = Q_NULLPTR);
    // internal index-based disconnect
    static bool disconnect(const QObject *sender, int signal_index,
                           const QObject *receiver, int method_index);
    static bool disconnectOne(const QObject *sender, int signal_index,
                              const QObject *receiver, int method_index);
    // internal slot-name based connect
    static void connectSlotsByName(QObject *o);

    // internal index-based signal activation
    static void activate(QObject *sender, int signal_index, void **argv);
    static void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv);
    static void activate(QObject *sender, int signal_offset, int local_signal_index, void **argv);

    static bool invokeMethod(QObject *obj, const char *member,
                             Qt::ConnectionType,
                             QGenericReturnArgument ret,
                             QGenericArgument val0 = QGenericArgument(Q_NULLPTR),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument());

    static inline bool invokeMethod(QObject *obj, const char *member,
                             QGenericReturnArgument ret,
                             QGenericArgument val0 = QGenericArgument(Q_NULLPTR),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument())
    {
        return invokeMethod(obj, member, Qt::AutoConnection, ret, val0, val1, val2, val3,
                val4, val5, val6, val7, val8, val9);
    }

    static inline bool invokeMethod(QObject *obj, const char *member,
                             Qt::ConnectionType type,
                             QGenericArgument val0 = QGenericArgument(Q_NULLPTR),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument())
    {
        return invokeMethod(obj, member, type, QGenericReturnArgument(), val0, val1, val2,
                                 val3, val4, val5, val6, val7, val8, val9);
    }

    static inline bool invokeMethod(QObject *obj, const char *member,
                             QGenericArgument val0 = QGenericArgument(Q_NULLPTR),
                             QGenericArgument val1 = QGenericArgument(),
                             QGenericArgument val2 = QGenericArgument(),
                             QGenericArgument val3 = QGenericArgument(),
                             QGenericArgument val4 = QGenericArgument(),
                             QGenericArgument val5 = QGenericArgument(),
                             QGenericArgument val6 = QGenericArgument(),
                             QGenericArgument val7 = QGenericArgument(),
                             QGenericArgument val8 = QGenericArgument(),
                             QGenericArgument val9 = QGenericArgument())
    {
        return invokeMethod(obj, member, Qt::AutoConnection, QGenericReturnArgument(), val0,
                val1, val2, val3, val4, val5, val6, val7, val8, val9);
    }

    QObject *newInstance(QGenericArgument val0 = QGenericArgument(Q_NULLPTR),
                         QGenericArgument val1 = QGenericArgument(),
                         QGenericArgument val2 = QGenericArgument(),
                         QGenericArgument val3 = QGenericArgument(),
                         QGenericArgument val4 = QGenericArgument(),
                         QGenericArgument val5 = QGenericArgument(),
                         QGenericArgument val6 = QGenericArgument(),
                         QGenericArgument val7 = QGenericArgument(),
                         QGenericArgument val8 = QGenericArgument(),
                         QGenericArgument val9 = QGenericArgument()) const;

    enum Call {
        InvokeMetaMethod,
        ReadProperty,
        WriteProperty,
        ResetProperty,
        QueryPropertyDesignable,
        QueryPropertyScriptable,
        QueryPropertyStored,
        QueryPropertyEditable,
        QueryPropertyUser,
        CreateInstance,
        IndexOfMethod,
        RegisterPropertyMetaType,
        RegisterMethodArgumentMetaType
    };

    int static_metacall(Call, int, void **) const;
    static int metacall(QObject *, Call, int, void **);

    struct { // private data
        const QMetaObject *superdata;
        const QByteArrayData *stringdata;
        const uint *data;
        typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
        StaticMetacallFunction static_metacall;
        const QMetaObject * const *relatedMetaObjects;
        void *extradata; //reserved for future use
    } d;
};

    struct { // private data
        const QMetaObject *superdata;
        const QByteArrayData *stringdata;
        const uint *data;
        typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
        StaticMetacallFunction static_metacall;
        const QMetaObject * const *relatedMetaObjects;
        void *extradata; //reserved for future use
    } d;

元对象 的所有数据都由该结构定义，

1、const QMetaObject *superdata;    父类的staticMetaObject指针

2、QByteArrayData *stringdata;         字符串数组，保存类的 类名，槽函数名  信号函数名等 字符串信息。

3、const uint *data;                               无符号整形数组，该数组是个预定义的复合数据结构，由QMetaObjectPrivate 类提供管理，保存了类的基本信息，和一些索引值

4、const QMetaObject * const *relatedMetaObjects;  和void *extradata;    MOC不会为他们生成对应的数据

MOC 为一个类生成元数据例子。类widget 包含三个信号 和 槽，分别为

protected slots:
    void TestSlot(QString &str);
signals:
    void TestSignal1(QString &str);
    void TestSignal2(QString &str,int i);
    void TestSignal3();

MOC生成的代码

QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_Widget_t {
    QByteArrayData data[];
    char stringdata0[];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Widget_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Widget_t qt_meta_stringdata_Widget = {
    {                                                             //对应QMetaObject的stringdata  ，QT_MOC_LITERAL宏来构成QByteArray对象，每个QByteArray对
QT_MOC_LITERAL(, , ), // "Widget"                                应一个下面\0结尾的字符串，以此方便对字符串数据的管理
QT_MOC_LITERAL(, , ), // "TestSignal1"
QT_MOC_LITERAL(, , ), // ""
QT_MOC_LITERAL(, , ), // "QString&"
QT_MOC_LITERAL(, , ), // "str"
QT_MOC_LITERAL(, , ), // "TestSignal2"
QT_MOC_LITERAL(, , ), // "i"
QT_MOC_LITERAL(, , ), // "TestSignal3"
QT_MOC_LITERAL(, , ) // "TestSlot"

    },
    "Widget\0TestSignal1\0\0QString&\0str\0"
    "TestSignal2\0i\0TestSignal3\0TestSlot"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Widget[] = {

说明：QT_MOC_LITERAL(0, 0, 6), // "Widget"  （0：序号，0,：字符（"Widget\0T..."）在字符串中的起始位置，6：字符长度）。

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

 // signals: name, argc, parameters, tag, flags     //其中第一值是QByteArrayData数组的索引值，以此来找到对应的字符串名称，第二个值是参数个数，第三个是参数
       ,    ,   ,    , 0x06 /* Public */,     //的大小
       ,    ,   ,    , 0x06 /* Public */,
       ,    ,   ,    , 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       ,    ,   ,    , 0x09 /* Protected */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | ,    ,
    QMetaType::Void, 0x80000000 | , QMetaType::Int,    ,    ,
    QMetaType::Void,

 // slots: parameters
    QMetaType::Void, 0x80000000 | ,    ,

               // eod
};

void Widget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)    //以名称或索引方式调用对应的信号函数
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Widget *_t = static_cast<Widget *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case : _t->TestSignal1((*reinterpret_cast< QString(*)>(_a[]))); break;
        case : _t->TestSignal2((*reinterpret_cast< QString(*)>(_a[])),(*reinterpret_cast< int(*)>(_a[]))); break;
        case : _t->TestSignal3(); break;
        case : _t->TestSlot((*reinterpret_cast< QString(*)>(_a[]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[]);
        void **func = reinterpret_cast<void **>(_a[]);
        {
            typedef void (Widget::*_t)(QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Widget::TestSignal1)) {
                *result = ;
                return;
            }
        }
        {
            typedef void (Widget::*_t)(QString & , int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Widget::TestSignal2)) {
                *result = ;
                return;
            }
        }
        {
            typedef void (Widget::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Widget::TestSignal3)) {
                *result = ;
                return;
            }
        }
    }
}

const QMetaObject Widget::staticMetaObject = {
    { &QWidget::staticMetaObject, qt_meta_stringdata_Widget.data,
      qt_meta_data_Widget,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}      //初始化静态对象staticMetaObject
};

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

void *Widget::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Widget.stringdata0))
        return static_cast<void*>(const_cast< Widget*>(this));
    return QWidget::qt_metacast(_clname);
}

int Widget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < )
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < )
            qt_static_metacall(this, _c, _id, _a);
        _id -= ;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < )
            *reinterpret_cast<int*>(_a[]) = -;
        _id -= ;
    }
    return _id;
}

// SIGNAL 0
void Widget::TestSignal1(QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, , _a);
}

// SIGNAL 1
void Widget::TestSignal2(QString & _t1, int _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, , _a);
}

// SIGNAL 2
void Widget::TestSignal3()
{
    QMetaObject::activate(this, &staticMetaObject, , Q_NULLPTR);
}
QT_END_MOC_NAMESPACE

其中  static const uint qt_meta_data_Widget[] = {
 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       4,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       3,       // signalCount

对应

struct QMetaObjectPrivate
{
    enum { OutputRevision = 7 }; // Used by moc, qmetaobjectbuilder and qdbus

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
  说明： 7,       // revision，就是将QMetaObjectPrivate中的revision复制为7.