2024年C C++最全Qt Moc及信号-槽源代码解析_qt_moc_literal(1)，C C++初级面试题2024

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

/****************************************************************************
** Meta object code from reading C++ file ‘test.h’
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.12.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include “…/…/mocTest/test.h”
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error “The header file ‘test.h’ doesn’t include .”
#elif Q_MOC_OUTPUT_REVISION != 67
#error “This file was generated using the moc from 5.12.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
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED

//此处省略见下文

QT_WARNING_POP
QT_END_MOC_NAMESPACE

moc\_test.cpp看起来很复杂，分三部分来看：


#### 2.1 类信息


位于moc\_test.cpp头部

struct qt_meta_stringdata_test_t { //定义保存类信息的结构体
QByteArrayData data[12];
char stringdata0[113];
};

QT\_MOC\_LITERAL宏的作用是为stringdata0中保存的每个函数名都创建一个QByteArrayData，宏参数为函数的索引值，偏移量，函数名长度。

#define QT_MOC_LITERAL(idx, ofs, len
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len,
qptrdiff(offsetof(qt_meta_stringdata_test_t, stringdata0) + ofs \

• idx * sizeof(QByteArrayData))
  )
  static const qt_meta_stringdata_test_t
  qt_meta_stringdata_test = { //初始化保存类信息的结构体
  {
  QT_MOC_LITERAL(0, 0, 4), // “test”
  QT_MOC_LITERAL(1, 5, 11), // “testSignal1”
  QT_MOC_LITERAL(2, 17, 0), // “”
  QT_MOC_LITERAL(3, 18, 11), //“testSignal2”
  QT_MOC_LITERAL(4, 30, 11), //“testSignal3”
  QT_MOC_LITERAL(5, 42, 12), // “valueChanged”
  QT_MOC_LITERAL(6, 55, 8), //“newValue”
  QT_MOC_LITERAL(7, 64, 9), //“testSlot1”
  QT_MOC_LITERAL(8, 74, 9), //“testSlot2”
  QT_MOC_LITERAL(9, 84, 8), //“setValue”
  QT_MOC_LITERAL(10, 93, 5), //“value”
  QT_MOC_LITERAL(11, 99, 13) //"identifyByMoc
  },
  “test\0testSignal1\0\0testSignal2\0testSignal3\0”
  “valueChanged\0newValue\0testSlot1\0”
  “testSlot2\0setValue\0value\0identifyByMoc”
  };
  #undef QT_MOC_LITERAL

static const uint qt_meta_data_test[] = {
//保存了信号，槽及moc识别的其他函数的个数，函数索引，返回类型，参数个数，参数类型等信息。

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

//signals: name, argc, parameters, tag, flags
1, 0, 54, 2, 0x06 /* Public */,
3, 0, 55, 2, 0x06 /* Public */,
4, 0, 56, 2, 0x06 /* Public */,
5, 1, 57, 2, 0x06 /* Public */,

//slots: name, argc, parameters, tag, flags
7, 0, 60, 2, 0x0a /* Public */,
8, 0, 61, 2, 0x0a /* Public */,
9, 1, 62, 2, 0x0a /* Public */,

//methods: name, argc, parameters, tag, flags
11, 0, 65, 2, 0x02 /* Public */,

//signals: parameters
QMetaType::Void,
QMetaType::Void,
QMetaType::Void,
QMetaType::Void, QMetaType::Int, 6,

//slots: parameters
QMetaType::Void,
QMetaType::Void,
QMetaType::Void, QMetaType::Int, 10,

//methods: parameters
QMetaType::Void,

  0        // eod

};

#### 2.2 signals实现


位于moc\_test.cpp底部：

// SIGNAL 0
void test::testSignal1()
{
QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void test::testSignal2()
{
QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void test::testSignal3()
{
QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void test::valueChanged(int _t1)
{
void *_a[] = { nullptr,const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

test.h中构造函数一个，普通函数一个(getValue)，signal四个，slot三个，Q\_INVOKABLE修饰的方法一个。其中三个槽函数需要自己在test.cpp里实现，四个信号函数由moc自动在moc\_test.cpp中实现，在注释可以看到索引根据声明顺序分别为0，1，2，3。


#### 2.3 Q\_OBJECT宏的展开


查找qobjectdefs.h,可以找到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,
“”)

正对应moc\_test.cpp里的函数等，我们取重要的几个：  
 位于moc\_test.cpp中部：


##### 2.3.1 qt\_static\_metacall

void test::qt_static_metacall(QObject *_o,QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<test *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->testSignal1(); break;
case 1: _t->testSignal2(); break;
case 2: _t->testSignal3(); break;
case 3: _t->valueChanged((*reinterpret_cast< int(*)>(_a[1])));break;
case 4: _t->testSlot1(); break;
case 5: _t->testSlot2(); break;
case 6: _t->setValue((*reinterpret_cast< int(*)>(_a[1])));break;
case 7: _t->identifyByMoc(); break;
default: ;
}
}else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
{
using _t = void (test:😗)();
if (*reinterpret_cast<_t *>(_a[1]) ==static_cast<_t>(&test::testSignal1)) {
*result = 0;
return;
}
}
{
using _t = void (test:😗)();
if (*reinterpret_cast<_t*>(_a[1]) == static_cast<_t>(&test::testSignal2)) {
*result = 1;
return;
}
}
{
using _t = void (test:😗)();
if (*reinterpret_cast<_t *>(_a[1]) ==
static_cast<_t>(&test::testSignal3)) {
*result = 2;
return;
}
}
{
using _t = void (test:😗)(int );
if (*reinterpret_cast<_t *>(_a[1]) ==
static_cast<_t>(&test::valueChanged)) {
*result = 3;
return;
}
}
}
}

根据函数索引调用槽函数，在这里可以看出信号函数也可以当作槽函数一样被调用，这也是信号槽调用过程的最后一步(先留个印象)


##### 2.3.2 staticMetaObject


test类的元对象(QMetaObject)，保存了test类的信息。保存的数据qt\_meta\_stringdata\_test.data及qt\_meta\_data\_test在moc文件的顶部定义并初始化。

QT_INIT_METAOBJECT const QMetaObject test::staticMetaObject = { {
&QObject::staticMetaObject,
qt_meta_stringdata_test.data,
qt_meta_data_test,
qt_static_metacall,
nullptr,
nullptr
} };

##### 2.3.3 metaObject


返回当前的QMetaObject,一般是返回staticMetaObject,即2介绍的。

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

##### 2.3.4 qt\_metacast


类型转换

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

##### 2.3.5 qt\_metacall

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

在内部调用了qt\_static\_metacall


**总结**：Moc的作用就是把Q\_OBJECT SIGNAL Q\_INVOKABLE等宏展开，并保存类中特定函数(signals,slots标签下的函数及Q\_INVOKABLE修饰的函数等)的信息，创建函数的回调。


### 三. connect


要使用Qt的信号-槽机制，必须要connect这一步。我们查看QObject::connect的源码：  
 QObject.cpp

QMetaObject::Connection
QObject::connect(const QObject *sender, const char *signal,
constQObject *receiver, const char *method, Qt::ConnectionType type)
{
//此处省略了函数参数检查，信号及槽函数索引获取，connect类型处理等代码。
//最后其实调用了QMetaObjectPrivate::connect
QMetaObject::Connection handle = QMetaObject::Connection(QMetaObjectPrivate::connect(
sender, signal_index, smeta, receiver, method_index_relative, rmeta ,type, types));
return handle;
}

QMetaObjectPrivate::connect同样位于QObject.cpp

QObjectPrivate::Connection *QMetaObjectPrivate::connect(const QObject *sender,
int signal_index, const QMetaObject *smeta,
const QObject *receiver, int method_index,
const QMetaObject *rmeta, int type, int *types)
{
QObject *s = const_cast<QObject *>(sender);
QObject *r = const_cast<QObject *>(receiver);

int method_offset = rmeta ? rmeta->methodOffset() : 0;
Q_ASSERT(!rmeta || QMetaObjectPrivate::get(rmeta)->revision >= 6);
QObjectPrivate::StaticMetaCallFunction callFunction =
rmeta ? rmeta->d.static_metacall : 0;

QOrderedMutexLocker locker(signalSlotLock(sender),
signalSlotLock(receiver));

if (type & Qt::UniqueConnection) {
QObjectConnectionListVector *connectionLists =QObjectPrivate::get(s)->connectionLists;
if (connectionLists && connectionLists->count() >signal_index) {
const QObjectPrivate::Connection *c2 = (*connectionLists)[signal_index].first;
int method_index_absolute = method_index + method_offset;
while (c2) {
if (!c2->isSlotObject && c2->receiver == receiver && c2->method() == method_index_absolute)
return 0;
c2 = c2->nextConnectionList;
}
}
type &= Qt::UniqueConnection - 1;
}

// QObjectPrivate::Connection实例化，
//存储了信号-槽链接的信息
QScopedPointerQObjectPrivate::Connection c(new QObjectPrivate::Connection);
c->sender = s;
c->signal_index = signal_index;
c->receiver = r;
c->method_relative = method_index;
c->method_offset = method_offset;
c->connectionType = type;
c->isSlotObject = false;
c->argumentTypes.store(types);
c->nextConnectionList = 0;
c->callFunction = callFunction;

//addConnection为信号发送者s保存了这个信号-槽链接，具体保存了什么，还需要
//分析QObjectPrivate::Connection以及QObjectPrivate::addConnection

QObjectPrivate::get(s)->addConnection(signal_index, c.data());

locker.unlock();
QMetaMethod smethod = QMetaObjectPrivate::signal(smeta, signal_index);
if (smethod.isValid())
s->connectNotify(smethod);

return c.take();
}

qobject\_p.h中定义了class QObjectPrivate  
 它的几个成员如下：

struct Connection
{
QObject *sender;
QObject *receiver;
union {
StaticMetaCallFunction callFunction;
QtPrivate::QSlotObjectBase *slotObj;
};
// The next pointer for the singly-linked ConnectionList
Connection *nextConnectionList;
//senders linked list
Connection *next;
Connection **prev;
ushort method_offset;
ushort method_relative;
uint signal_index : 27; // In signal range (see QObjectPrivate::signalIndex())
ushort connectionType : 3; // 0 == auto, 1 == direct, 2 == queued, 4 == blocking
//省略部分代码
};

Connection结构体保存了一个连接。其中的信息包括信号发送者指针，信号接收者指针以及指向下一个Connection的指针，信号索引，连接类型等


一个信号可以对应多个槽函数，这里用ConnectionList保存一个信号对应的所有连接。它是一个单向链表，每个节点都是一个Connection，通过它内部的nextConnectionList指针指向下一个Connection。在这里仅保存头尾指针即可。

struct ConnectionList {
ConnectionList() : first(nullptr), last(nullptr) {}
Connection *first;
Connection *last;
};

connectionLists保存此对象作为信号发送者所对应的所有连接。这个向量里每个元素都是一个ConnectionList单链表

QObjectConnectionListVector *connectionLists;

QObject.cpp里定义了QObjectConnectionListVector

class QObjectConnectionListVector : public
QVectorQObjectPrivate::ConnectionList
{
public:
bool orphaned; //the QObject owner of this vector has been destroyed while the vector was inUse
bool dirty; //some Connection have been disconnected (their receiver is 0) but not removed from the list yet
int inUse; //number of functions that are currently accessing this object or its connections
QObjectPrivate::ConnectionList allsignals;

QObjectConnectionListVector(): QVectorQObjectPrivate::ConnectionList(), orphaned(false),
dirty(false), inUse(0)
{}

QObjectPrivate::ConnectionList &operator[](int at)
{
if (at < 0)
return allsignals;
return QVectorQObjectPrivate::ConnectionList::operator;
}
};

Connection \*next和Connection\*\*prev是此对象作为信号接收者时，保存发送者的双向链表的操作指针，这里的内容待以后补充。


接下来看最后的addConnection, 位于QObject.cpp

void QObjectPrivate::addConnection(int signal, Connection *c)
{
Q_ASSERT(c->sender == q_ptr);
if (!connectionLists)
connectionLists = new QObjectConnectionListVector();
if (signal >= connectionLists->count())
connectionLists->resize(signal + 1);

//根据信号索引取得此信号所对应的链表，并把此连接加入链表中。
ConnectionList &connectionList = (*connectionLists)[signal];
if (connectionList.last) {
connectionList.last->nextConnectionList = c;
}else {
connectionList.first = c;
}
connectionList.last = c;

cleanConnectionLists();

//下面是对Connection* QObjectPrivate::senders双向链表的操作
c->prev = &(QObjectPrivate::get(c->receiver)->senders);
c->next = *c->prev;
*c->prev = c;
if (c->next)
c->next->prev = &c->next;

if (signal < 0) {
connectedSignals[0] = connectedSignals[1] = ~0;
}else if (signal < (int)sizeof(connectedSignals) * 8) {
connectedSignals[signal >> 5] |= (1 << (signal & 0x1f));
}
}

### 四. activate


连接完成后，我们调用信号函数，从moc\_test.cpp里对信号函数的实现可知，其实是调用了QMetaObject::activate(this, &staticMetaObject, 3, \_a);

// SIGNAL 3
void test::valueChanged(int _t1)
{
void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

MetaObject, 3, _a);

// SIGNAL 3
void test::valueChanged(int _t1)
{
   void \*_a[] = { nullptr, const\_cast<void\*>(reinterpret\_cast<const void\*>(&_t1)) };
   QMetaObject::activate(this, &staticMetaObject, 3, _a);
}


[外链图片转存中...(img-mm3pdTbw-1715529884314)]
[外链图片转存中...(img-gXO9JODT-1715529884314)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**