Q_OBJECT

test_moc.h
```
#ifndef TEST_MOC_H
#define TEST_MOC_H

#include <QObject>

class TestMoc : public QObject
{
    Q_OBJECT  // 必须要有这个宏

public:
    explicit TestMoc(QObject *parent = nullptr) : QObject(parent) {}

signals:
    void testSignal();  // 至少有一个信号或槽
};

#endif // TEST_MOC_H

```
```

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

\*\* Meta object code from reading C++ file 'test\_moc.h'

\*\*

\*\* Created by: The Qt Meta Object Compiler version 68 (Qt 6.8.3)

\*\*

\*\* WARNING! All changes made in this file will be lost!

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

#include "test\_moc.h"

#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>

#include <QtCore/qxptype\_traits.h>

#if !defined(Q\_MOC\_OUTPUT\_REVISION)

#error "The header file 'test\_moc.h' doesn't include <QObject>."

#elif Q\_MOC\_OUTPUT\_REVISION != 68

#error "This file was generated using the moc from 6.8.3. It"

#error "cannot be used with the include files from this version of Qt."

#error "(The moc has changed too much.)"

#endif

#ifndef Q\_CONSTINIT

#define Q\_CONSTINIT

#endif

QT\_WARNING\_PUSH

QT\_WARNING\_DISABLE\_DEPRECATED

QT\_WARNING\_DISABLE\_GCC("-Wuseless-cast")

namespace {

struct qt\_meta\_tag\_ZN7TestMocE\_t {};

} // unnamed namespace

#ifdef QT\_MOC\_HAS\_STRINGDATA

static constexpr auto qt\_meta\_stringdata\_ZN7TestMocE \= QtMocHelpers::stringData(

"TestMoc",

"testSignal",

""

);

#else  // !QT\_MOC\_HAS\_STRINGDATA

#error "qtmochelpers.h not found or too old."

#endif // !QT\_MOC\_HAS\_STRINGDATA

Q\_CONSTINIT static const uint qt\_meta\_data\_ZN7TestMocE\[\] \= {

//类的元数据，包括方法、信号数量
 // content:

12,       // revision

0,       // classname

0,    0, // classinfo

1,   14, // methods

0,    0, // properties

0,    0, // enums/sets

0,    0, // constructors

0,       // flags

1,       // signalCount

// signals: name, argc, parameters, tag, flags, initial metatype offsets

1,    0,   20,    2, 0x06,    1 /\* Public \*/,

// signals: parameters

QMetaType::Void,

0        // eod

};

Q\_CONSTINIT const QMetaObject TestMoc::staticMetaObject \= { {
//静态元对象，
    QMetaObject::SuperData::link<QObject::staticMetaObject\>(),

qt\_meta\_stringdata\_ZN7TestMocE.offsetsAndSizes,

qt\_meta\_data\_ZN7TestMocE,

qt\_static\_metacall,

nullptr,

qt\_incomplete\_metaTypeArray<qt\_meta\_tag\_ZN7TestMocE\_t,

// Q\_OBJECT / Q\_GADGET

QtPrivate::TypeAndForceComplete<TestMoc, std::true\_type\>,

// method 'testSignal'

QtPrivate::TypeAndForceComplete<void, std::false\_type\>

\>,

nullptr

} };

void TestMoc::qt\_static\_metacall(QObject \*\_o, QMetaObject::Call \_c, int \_id, void \*\*\_a)
//元调用函数：
{

auto \*\_t \= static\_cast<TestMoc \*>(\_o);

if (\_c \== QMetaObject::InvokeMetaMethod) {

switch (\_id) {

case 0: \_t\->testSignal(); break;

default: ;

}

if (\_c \== QMetaObject::IndexOfMethod) {

int \*result \= reinterpret\_cast<int \*>(\_a\[0\]);

{

using \_q\_method\_type \= void (TestMoc::\*)();

if (\_q\_method\_type \_q\_method \= &TestMoc::testSignal; \*reinterpret\_cast<\_q\_method\_type \*>(\_a\[1\]) \== \_q\_method) {

\*result \= 0;

return;

}

const QMetaObject \*TestMoc::metaObject() const

{

return QObject::d\_ptr\->metaObject ? QObject::d\_ptr\->dynamicMetaObject() : &staticMetaObject;

}

void \*TestMoc::qt\_metacast(const char \*\_clname)

{

if (!\_clname) return nullptr;

if (!strcmp(\_clname, qt\_meta\_stringdata\_ZN7TestMocE.stringdata0))

return static\_cast<void\*>(this);

return QObject::qt\_metacast(\_clname);

}

int TestMoc::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 < 1)

qt\_static\_metacall(this, \_c, \_id, \_a);

\_id \-= 1;

}

if (\_c \== QMetaObject::RegisterMethodArgumentMetaType) {

if (\_id < 1)

\*reinterpret\_cast<QMetaType \*>(\_a\[0\]) \= QMetaType();

\_id \-= 1;

}

return \_id;

}

// SIGNAL 0
//信号实现

void TestMoc::testSignal()

{

QMetaObject::activate(this, &staticMetaObject, 0, nullptr);

}

QT\_WARNING\_POP

```