QT5核心机制深度解析：从信号槽到事件循环的源码之旅

// myobject.h
class MyObject : public QObject {
    Q_OBJECT
public:
    explicit MyObject(QObject *parent = nullptr);
signals:
    void mySignal(int value);
public slots:
    void mySlot(int value);
};

// 元数据数组：方法索引、参数类型、签名
static const uint qt_meta_data_MyObject[] = {
 // content:
       7,       // revision
       0,       // classname index
       0,    0, // classinfo
       2,   14, // methods (2个)
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount (第一个是信号)

 // signals: name, argc, parameters
       1,    1,   24, // signal mySignal(int)
 // slots: name, argc, parameters
       2,    1,   27, // slot mySlot(int)

 // 字符串池
       0, // "MyObject"
       1, // "mySignal"
       2, // "mySlot"
       3, // "int"
};

// 静态元对象
static const QMetaObject MyObject_metaObject = {
    { &QObject::staticMetaObject, // 父元对象
      qt_meta_data_MyObject,
      qt_static_metacall,         // 回调函数
      nullptr, nullptr }
};

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

// 回调函数实现：根据调用索引分发
void MyObject::qt_static_metacall(QObject *_o, QMetaObject::Call _c, 
                                  int _id, void **_a) {
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *obj = static_cast<MyObject*>(_o);
        switch (_id) {
        case 0: obj->mySignal((*reinterpret_cast<int*>(_a[1]))); break;
        case 1: obj->mySlot((*reinterpret_cast<int*>(_a[1]))); break;
        }
    }
}

static QMetaObject::Connection connect(const QObject *sender, 
                                       const char *signal,
                                       const QObject *receiver,
                                       const char *member,
                                       Qt::ConnectionType type);

struct Connection {
    QObject *receiver;
    void *slot;                // 指向槽函数或functor
    int method_index;          // 槽在元对象中的索引
    int signal_index;          // 信号索引（带偏移）
    int connectionType;        // Auto, Direct, Queued, BlockingQueued
    QAtomicPointer<Connection> next;   // 链表指针
    // ... 其他原子操作、线程ID等
};

// 信号函数的实现（由moc生成）
void MyObject::mySignal(int _t1) {
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

static void activate(QObject *sender, const QMetaObject *m, 
                     int local_signal_index, void **argv);

void QMetaObject::activate(QObject *sender, const QMetaObject *m,
                           int local_signal_index, void **argv) {
    if (!sender) return;
    QObjectPrivate *sd = QObjectPrivate::get(sender);
    // 获取信号对应的连接链表头
    int signal_index = m->methodOffset() + local_signal_index;
    QObjectPrivate::Connection *c = sd->connections.loadRelaxed();
    // 遍历链表
    while (c) {
        if (c->signal_index == signal_index) {
            // 根据连接类型派发
            if (c->connectionType == Qt::DirectConnection) {
                // 直接调用：通过元对象回调
                if (c->method_index >= 0) {
                    m->metacall(c->receiver, QMetaObject::InvokeMetaMethod,
                                c->method_index, argv);
                }
            } else if (c->connectionType == Qt::QueuedConnection) {
                // 构造事件入队
                QMetaCallEvent *ev = new QMetaCallEvent(c->method_index, 
                                       c->receiver, argv, ...);
                QCoreApplication::postEvent(c->receiver, ev);
            } else if (c->connectionType == Qt::BlockingQueuedConnection) {
                // 使用信号量同步等待
                QSemaphore sem;
                QMetaCallEvent *ev = ...;
                QCoreApplication::postEvent(c->receiver, ev, &sem);
                sem.acquire();
            }
        }
        c = c->next.loadRelaxed();
    }
}

bool QObject::event(QEvent *e) {
    if (e->type() == QEvent::MetaCall) {
        QMetaCallEvent *mce = static_cast<QMetaCallEvent*>(e);
        // 调用元对象回调，还原参数
        mce->metaCall(this);
        return true;
    }
    // ...
}

int QEventLoop::exec(ProcessEventsFlags flags) {
    Q_D(QEventLoop);
    while (!d->exit) {
        processEvents(flags | WaitForMoreEvents);
        // 处理所有待发事件
    }
    return d->returnCode;
}

bool QEventLoop::processEvents(ProcessEventsFlags flags) {
    Q_D(QEventLoop);
    return d->eventDispatcher->processEvents(flags);
}

bool QCoreApplication::notify(QObject *receiver, QEvent *event) {
    // 全局事件过滤器
    if (receiver->isWidgetType() && ...) { ... }
    // 调用接收者的event()虚函数
    return receiver->event(event);
}

gdb --args ./myapp
break QMetaObject::activate
run
# emit信号时触发，打印信息
p *sd->connections
p c->method_index