1.QT元对象系统、信号槽概述、宏Q_OBJECT

一、元对象系统（Meta-Object System）

Qt添加C++原本不具备的元对象系统，元对象系统提供了信号槽机制，运行时类型信息和动态属性系统。

 

元对象系统基于三点：

1.元对象系统为以QObject类为基类的对象提供了特有的功能

2.类private的Q_OBJECT宏使得以QObject类为基类的对象能够使用元对象功能

3.元对象编译器（Meta-Object Compiler moc）为每个QObject子类生成必要的代码，以具体实现元对象功能。

 

moc读取C ++源文件。如果找到包含Q_OBJECT宏的类，它将生成对应的C++源文件，这些源文件中包含这些类的元对象代码。生成的源文件被#include在类的源文件中，被编译链接到类的二进制代码中。

通常，这个新的C++ 源文件会在以前的C++ 源文件名前面加上 moc_ 作为新文件的文件名。由moc所生成的文件必须被编译和链接，因为这些C++文件具体实现了元对象系统的特有功能，否则，在链接的过程中就会失败。不过一般情况下，程序运行时，如果发现没有找到由moc所生成的文件，moc会重新生成，然后再编译链接这些文件

 

由moc所生成的文件的位置在由QT自动生成的编译链接产的目录中，名字一般是这样的

里面包含的文件是这样的

除了提供信号和槽机制用于对象之间的通信（这是主要任务），元对象系统还提供了更多的特性：

QObject::metaObject() 函数返回当前类对象关联的元对象（meta-object）。

QMetaObject::className() 函数返回当前对象的类名称字符串，而不需要 C++ 编译器原生的运行时类型信息（run-time type information，RTTI）支持。

QObject::inherits() 函数判断当前对象是否从某个基类派生，判断某个基类是否位于从 QObject 到对象当前类的继承树上。

QObject::tr() 和 QObject::trUtf8() 函数负责翻译国际化字符串。

QObject::setProperty() 和 QObject::property() 函数用于动态设置和获取属性，都通过属性名称字符串来 操作。

QMetaObject::newInstance() 构建一个当前类的新实例对象。

元对象系统还提供了 qobject_cast() 函数，可以对基于 QObject 的类对象进行转换，qobject_cast() 函数功能类似标准 C++ 的 dynamic_cast()。当然 qobject_cast() 的优势在于不需要编译器支持 RTTI，转换成功，会返回对应类型的指针，否则返回空指针

 

在使用QT时，一定要在类的private区域加上Q_OBJECT并直接或间接继承QObject，只有这样，才能使用元对象系统提供的特有机制，否则就和普通的C++代码没啥区别

 

二、信号槽概述

信号槽是元对象系统的特有机制之一，也是最重要的机制。信号槽用于对象间通信。 信号的实现是由moc自动生成的，不得在自己开发的cpp文件中实现

Qt自带许多预定义的信号和槽函数，也可以自定义信号和槽函数，而且，槽函数可以是虚函数。

可以将任意数量的信号连接到单个槽上，信号也可以连接到任意数量的槽上，如果将多个槽函数连接到一个信号，则发出信号时，将按照连接的顺序依次执行槽函数。甚至可以将一个信号连接到另一个信号上（此时，发出第一个信号时立即触发第二个信号）。

一般情况下，发出信号后，与其连接的槽函数会立即执行。一旦所有槽函数都返回后，将继续执行emit语句之后的代码。当排队连接时，emit关键字之后的代码不会等待槽函数执行完，而是将继续执行emit后的代码，并且稍后执行槽函数。

 

使用信号槽的前提是直接或间接继承QObject并在子类的private区域添加宏Q_OBJECT

原因：

1.继承QObject是为了调用connect完成信号槽的链接，因为这两个函数都是在QObject中实现的。只有继承了这个类，才能在子类中使用该函数

2.包含宏Q_OBJECT主要是为了具体实现QT子类对象的元对象信息，实现信号槽的通信

 

三、Q_OBJECT宏

Q_OBJECT宏展开如下

/* qmake ignore Q_OBJECT */
#define Q_OBJECT \
public: \
    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，就相当于添加了上面的这些函数和宏，这样的话，具体的类中就有上面的这些函数、数据和宏，并通过moc生成的C++文件中实现

其中，

1、static const QMetaObject staticMetaObject;保存该类的元对象系统信息，为类的所有对象共享；

2、virtual const QMetaObject *metaObject() const;这个函数通常情况下会返回类的静态元对象staticMetaObject，如果在 QML 程序中，会返回非静态元对象。

3、virtual void *qt_metacast(const char *);这个函数将派生类对象的指针安全地转为基类对象指针，转换失败返回空

4、virtual int qt_metacall(QMetaObject::Call, int, void **);这个函数负责槽函数的调用和属性系统的读写，内部会调用qt_static_metacall(QObject *, QMetaObject::Call, int, void **)

5、static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);这个函数实现了具体槽函数的调用

6、QT_TR_FUNCTIONS负责实现翻译国际化字符串，展开后如下

#  define QT_TR_FUNCTIONS \
    static inline QString tr(const char *s, const char *c = nullptr, int n = -1) \
        { return staticMetaObject.tr(s, c, n); } \
    QT_DEPRECATED static inline QString trUtf8(const char *s, const char *c = nullptr, int n = -1) \
        { return staticMetaObject.tr(s, c, n); }

都是调用 staticMetaObject.tr(s, c, n)

QT_TR_FUNCTIONS和Q_OBJECT都在qobjectdefs.h中定义

 

Q_OBJECT的展开会在每个具体的类的moc文件中实现，之后，会通过下面的代码来生成并解析moc文件

头文件

#include <QObject>
#include <iostream>

class moctest : public QObject
{
    Q_OBJECT
public:
    moctest();
    ~moctest();
    void f1();
    int f2();
signals:
        void sigf1(double);
        int sigf2(char, int);
protected slots:
        void slotf(double);
        int slotf2(char);
        bool slotf3(char) {return false;}
};

源文件

#include "widget.h"

using namespace std;

moctest::moctest()
{
    connect(this, &moctest::sigf1, this, &moctest::slotf);
    connect(this, &moctest::sigf2, this, &moctest::slotf2);
}
moctest::~moctest()
{
}
void moctest::slotf(double d)
{
    cout << "slotFunc" << endl;
}
int moctest::slotf2(char c)
{
    cout << "slotFunc2" << endl;
    return c;
}
void moctest::f1()
{

}
int moctest::f2()
{
}

生成的moc文件如下

/****************************************************************************
** Meta object code from reading C++ file 'widget.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.14.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include <memory>
#include "../moctest/widget.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'widget.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.14.1. 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
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_moctest_t {
    QByteArrayData data[7];
    char stringdata0[41];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_moctest_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_moctest_t qt_meta_stringdata_moctest = {
    {
QT_MOC_LITERAL(0, 0, 7), // "moctest"
QT_MOC_LITERAL(1, 8, 5), // "sigf1"
QT_MOC_LITERAL(2, 14, 0), // ""
QT_MOC_LITERAL(3, 15, 5), // "sigf2"
QT_MOC_LITERAL(4, 21, 5), // "slotf"
QT_MOC_LITERAL(5, 27, 6), // "slotf2"
QT_MOC_LITERAL(6, 34, 6) // "slotf3"

    },
    "moctest\0sigf1\0\0sigf2\0slotf\0slotf2\0"
    "slotf3"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_moctest[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       5,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       2,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   39,    2, 0x06 /* Public */,
       3,    2,   42,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       4,    1,   47,    2, 0x09 /* Protected */,
       5,    1,   50,    2, 0x09 /* Protected */,
       6,    1,   53,    2, 0x09 /* Protected */,

 // signals: parameters
    QMetaType::Void, QMetaType::Double,    2,
    QMetaType::Int, QMetaType::Char, QMetaType::Int,    2,    2,

 // slots: parameters
    QMetaType::Void, QMetaType::Double,    2,
    QMetaType::Int, QMetaType::Char,    2,
    QMetaType::Bool, QMetaType::Char,    2,

       0        // eod
};

void moctest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<moctest *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->sigf1((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 1: { int _r = _t->sigf2((*reinterpret_cast< char(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = std::move(_r); }  break;
        case 2: _t->slotf((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 3: { int _r = _t->slotf2((*reinterpret_cast< char(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = std::move(_r); }  break;
        case 4: { bool _r = _t->slotf3((*reinterpret_cast< char(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (moctest::*)(double );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&moctest::sigf1)) {
                *result = 0;
                return;
            }
        }
        {
            using _t = int (moctest::*)(char , int );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&moctest::sigf2)) {
                *result = 1;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject moctest::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_meta_stringdata_moctest.data,
    qt_meta_data_moctest,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *moctest::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_moctest.stringdata0))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int moctest::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) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 5;
    }
    return _id;
}

// SIGNAL 0
void moctest::sigf1(double _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
int moctest::sigf2(char _t1, int _t2)
{
    int _t0{};
    void *_a[] = { const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t0))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
    return _t0;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE

后面会对moc文件进行解读

 

参考

Qt5.14源码

https://doc.qt.io/qt-5.14/topics-core.html

 

欢迎大家评论交流，作者水平有限，如有错误，欢迎指出