QT5信号槽机制原理与源码深度剖析：从moc到事件循环的完整链路

class Test : public QObject {
    Q_OBJECT
public:
    Test(QObject *parent = nullptr) : QObject(parent) {}
signals:
    void sig(int x, const QString &s);
};

// 信号实际是个普通函数，但由 moc 实现
void Test::sig(int x, const QString &s) {
    QMetaObject::activate(this, &staticMetaObject, 0, 
                          Q_ARG(int, x), Q_ARG(QString, s));
}

void QMetaObject::activate(QObject *sender, const QMetaObject *m, 
                           int local_signal_index, void **argv) {
    int signal_index = m->methodOffset() + local_signal_index;
    // 拿到发送者的 QObjectPrivate
    QObjectPrivate *sp = QObjectPrivate::get(sender);
    if (!sp->connections) return;
    // 如果当前线程与接收者线程不同，且非阻塞模式，转为异步
    if (sp->threadData->thread != QThread::currentThread()) {
        // 构造 QMetaCallEvent 并投递
        ...
        return;
    }
    // 同步调用链
    activate_sender(sender, signal_index, argv, sp->connections);
}

struct Connection {
    QObject *receiver;
    int method_index;          // 槽函数在接收者元对象中的索引
    int signal_index;          // 发送者信号索引（用于唯一连接判断）
    int connectionType;        // AutoConnection, DirectConnection, QueuedConnection
    QAtomicPointer<Connection> next;
    ...
};

template<typename Func1, typename Func2>
static QMetaObject::Connection connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, 
                                       Func1 signal, const typename QtPrivate::FunctionPointer<Func2>::Object *receiver, 
                                       Func2 slot, Qt::ConnectionType type) {
    // 编译期通过 FunctionPointer 提取函数签名
    using SignalType = typename QtPrivate::FunctionPointer<Func1>::Arguments;
    using SlotType   = typename QtPrivate::FunctionPointer<Func2>::Arguments;
    // 静态断言检查参数兼容性
    static_assert(QtPrivate::CheckCompatibleArguments<SignalType, SlotType>::value, ...);
    // 生成一个唯一的槽索引（若为普通函数指针，则动态生成）
    int *slotIndex = new int;
    *slotIndex = QObjectPrivate::get(receiver)->methodIndexForSlot(static_cast<Func2>(slot));
    ...
}

static void activate_sender(QObject *sender, int signal_index, void **argv, 
                            QObjectPrivate::ConnectionList *connections) {
    QObjectPrivate::Connection *c = connections->signals[signal_index];
    while (c) {
        if (c->receiver) {
            // 获取接收者的元对象
            const QMetaObject *rmo = c->receiver->metaObject();
            // 通过 method_index 调用
            rmo->method_handle(c->method_index, ...);
        }
        c = c->next;
    }
}

int QMetaObject::metacall(QObject *obj, int id, int argc, void **argv) {
    if (id < 0) return id;
    switch (id - obj->metaObject()->methodOffset()) {
        case 0: obj->qt_static_metacall(QMetaObject::InvokeMetaMethod, 0, ...); break;
        ...
    }
}

QMetaCallEvent *ev = new QMetaCallEvent(method_index, argv, ...);
// 内部会调用 qMetaTypeConstructors 复制参数

bool QObject::event(QEvent *e) {
    if (e->type() == QEvent::MetaCall) {
        QMetaCallEvent *mce = static_cast<QMetaCallEvent*>(e);
        // 使用之前保存的 method_index 和参数执行
        mce->placeMetaCall(this);
        return true;
    }
    ...
}

QObject::~QObject() {
    if (d_ptr->connections) {
        QObjectPrivate::clearConnections(d_ptr->connections, this);
        delete d_ptr->connections;
    }
}

class PerfTest : public QObject {
    Q_OBJECT
public:
    void directCall(int) { /* 空 */ }
signals:
    void sig(int);
public slots:
    void slot(int) { /* 空 */ }
};
// 测两种：DirectConnection 和 AutoConnection（同线程即直接）

struct MiniConnection {
    void (*slot)(void*); // 函数指针
    void *receiver;
};
class MiniObject {
    std::vector<MiniConnection> conns[16]; // 最多16个信号
protected:
    void emitSignal(int idx, void *arg) {
        for (auto &c : conns[idx]) c.slot(c.receiver);
    }
};