Qt Signal Slot

QMetaObject::Connection QObject::connect(
    const QObject *sender, const char *signal,
    const QObject *receiver, const char *method,
    Qt::ConnectionType type):
  // signal, method 的类型为 char *, 是因为 SIGNAL 和 SLOT 宏实际上为
  // # define SLOT(a)     "1"#a
  // # define SIGNAL(a)   "2"#a
  // 它们把要调用的 signal slot 变成为字符串
  // 找到 signal index
  int signal_index = QMetaObjectPrivate::indexOfSignalRelative(
            &smeta, signalName, signalTypes.size(), signalTypes.constData());
    for (const QMetaObject *m = *baseObject; m; m = m->d.superdata) : 
      int i = (MethodType == MethodSignal)
            ? (priv(m->d.data)->signalCount - 1) : (priv(m->d.data)->methodCount - 1);
      const int end = (MethodType == MethodSlot)
                    ? (priv(m->d.data)->signalCount) : 0;

      // 使用 metadata 进行了某种字符串的匹配
      for (; i >= end; --i) : 
        int handle = priv(m->d.data)->methodData + 5*i;
        if (methodMatch(m, handle, name, argc, types)): 
            *baseObject = m;
            return i;
    return -1;

  // 找到 slot index
  method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(
    &rmeta, methodName, methodTypes.size(), methodTypes.constData());

  // connect, 实际上是把 slot index 加到 signal index 对应的链表上
  QMetaObjectPrivate::connect(
    sender, signal_index, smeta, receiver, method_index_relative, rmeta ,type, types)

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)
  std::unique_ptr<QObjectPrivate::Connection> c{new QObjectPrivate::Connection};
  c->sender = s;
  c->signal_index = signal_index;
  c->receiver.storeRelaxed(r);
  c->method_relative = method_index;
  c->method_offset = method_offset;
  QObjectPrivate::get(s)->addConnection(signal_index, c.get());
    ConnectionList &connectionList = cd->connectionsForSignal(signal);
      return signalVector.loadRelaxed()->at(signal);
    // ... 操作链表
    connectionList.first.storeRelaxed(c);
    c->prevConnectionList = connectionList.last.loadRelaxed();
    connectionList.last.storeRelaxed(c);
    c->next = *c->prev;
    *c->prev = c;
    // ...

void QMetaObject::activate(QObject *sender, const QMetaObject *m, int local_signal_index,void **argv)
  doActivate(sender, signal_index, argv);
    list = &signalVector->at(signal_index);
  // 遍历所有的 slot, 根据 connection type 和 receiver 是否和 sender 在相同的
  // thread, 决定是直接调用, postEvent, 或者 postEvent 并阻塞 
  do : 
    QObjectPrivate::Connection *c = list->first.loadRelaxed();
    do : 
      QObject * const receiver = c->receiver.loadRelaxed();
      bool receiverInSameThread;
      receiverInSameThread = currentThreadId == td->threadId.loadRelaxed();
      // determine if this connection should be sent immediately or
      // put into the event queue
      if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread)
          || (c->connectionType == Qt::QueuedConnection)): 
        queued_activate(sender, signal_index, c, argv);
        continue;
      else if (c->connectionType == Qt::BlockingQueuedConnection):
        if (receiverInSameThread):
            QSemaphore semaphore;
            {
                QCoreApplication::postEvent(receiver, ev);
            }
            semaphore.acquire();
      else:
        const int method = c->method_relative + c->method_offset;
        QMetaObject::metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv);
    while ((c = c->nextConnectionList.loadRelaxed()) != nullptr && c->id <= highestConnectionId);