void MainWindow::onClickButton()
{
  qDebug()<<"on click button";
  const QMetaObject* metaObject = this->metaObject();
  qDebug()<<metaObject->className();
  qDebug()<<metaObject->superClass()->className();

  int methodIndex = metaObject->indexOfMethod("testFunction()");
  qDebug()<<methodIndex;
  qDebug()<<metaObject->method(methodIndex).name();
  metaObject->method(methodIndex).invoke(this);

  QMetaObject::invokeMethod(this, "testFunction");
}

public:
  Q_OBJECT_CHECK
  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_WARNING_POP
  QT_TR_FUNCTIONS
private:
  Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
  struct QPrivateSignal {};

define slots
define signals public
define emit

signals:
  void clickButton(int value);

  void clickButton2();

// SIGNAL 0
void MainWindow::clickButton(int _t1)
{
  void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
  QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void MainWindow::clickButton2()
{
  QMetaObject::activate(this, &staticMetaObject, 1, Q_NULLPTR);
}

# define SLOT(a)   qFlagLocation("1"#a QLOCATION)
# define SIGNAL(a)  qFlagLocation("2"#a QLOCATION)

const char *qFlagLocation(const char *method)
{
  QThreadData *currentThreadData = QThreadData::current(false);
  if (currentThreadData != 0)
    currentThreadData->flaggedSignatures.store(method);
  return method;
}

void store(const char* method)
{ locations[idx++ % Count] = method; }

qDebug()<<SIGNAL(clickButton(int));	//2clickButton(int)
qDebug()<<SLOT(onClickButton());	//1onClickButton()

QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal,
                   const QObject *receiver, const char *method,
                   Qt::ConnectionType type)
{
  if (sender == 0 || receiver == 0 || signal == 0 || method == 0) {
    qWarning("QObject::connect: Cannot connect %s::%s to %s::%s",
         sender ? sender->metaObject()->className() : "(null)",
         (signal && *signal) ? signal+1 : "(null)",
         receiver ? receiver->metaObject()->className() : "(null)",
         (method && *method) ? method+1 : "(null)");
    return QMetaObject::Connection(0);
  }
  QByteArray tmp_signal_name;

  if (!check_signal_macro(sender, signal, "connect", "bind"))
    return QMetaObject::Connection(0);
  const QMetaObject *smeta = sender->metaObject();//獲取發(fā)送者的元數(shù)據(jù)對象
  const char *signal_arg = signal;//信號
  ++signal; //skip code
  QArgumentTypeArray signalTypes;//信號參數(shù)類型數(shù)組
  Q_ASSERT(QMetaObjectPrivate::get(smeta)->revision >= 7);
  //信號轉(zhuǎn)換為簽名，并得到信號參數(shù)類型數(shù)組
  QByteArray signalName = QMetaObjectPrivate::decodeMethodSignature(signal, signalTypes);
  //找到信號索引
  int signal_index = QMetaObjectPrivate::indexOfSignalRelative(
      &smeta, signalName, signalTypes.size(), signalTypes.constData());
  //小于0表示，表示信號索引有問題
  if (signal_index < 0) {
    // check for normalized signatures
    //將信號重新規(guī)范化，再進行上面的簽名轉(zhuǎn)換，并重新得到索引
    tmp_signal_name = QMetaObject::normalizedSignature(signal - 1);
    signal = tmp_signal_name.constData() + 1;

    //重新進行簽名轉(zhuǎn)換，并得到參數(shù)類型列表
    signalTypes.clear();
    signalName = QMetaObjectPrivate::decodeMethodSignature(signal, signalTypes);
    smeta = sender->metaObject();
    signal_index = QMetaObjectPrivate::indexOfSignalRelative(
        &smeta, signalName, signalTypes.size(), signalTypes.constData());
  }
  //重新獲取的信號索引還是無效，則是頭文件中信號的定義出錯，找不到信號，報錯信號不存在
  if (signal_index < 0) {
    err_method_notfound(sender, signal_arg, "connect");
    err_info_about_objects("connect", sender, receiver);
    return QMetaObject::Connection(0);
  }
  //根據(jù)當(dāng)前信號的索引找到最原始的信號的索引，因為信號是可以被繼承，這里找的祖先信號
  signal_index = QMetaObjectPrivate::originalClone(smeta, signal_index);
  signal_index += QMetaObjectPrivate::signalOffset(smeta);//信號的索引再加上信號的偏移量

  QByteArray tmp_method_name;
  //提取槽的編碼，應(yīng)該是QSLOT_CODE或者QSIGNAL_CODE，用于判斷槽是信號還是方法
  int membcode = extract_code(method);

  //檢查槽編碼，槽可以是槽函數(shù)或者信號，初次以為，都無效
  if (!check_method_code(membcode, receiver, method, "connect"))
    return QMetaObject::Connection(0);
  const char *method_arg = method;
  ++method; // skip code

  QArgumentTypeArray methodTypes;
  //轉(zhuǎn)換槽簽名，并獲取槽的參數(shù)類型列表
  QByteArray methodName = QMetaObjectPrivate::decodeMethodSignature(method, methodTypes);
  const QMetaObject *rmeta = receiver->metaObject();//獲取接受者的元數(shù)據(jù)對象
  int method_index_relative = -1;
  Q_ASSERT(QMetaObjectPrivate::get(rmeta)->revision >= 7);
  switch (membcode) {
  case QSLOT_CODE://接受者是槽函數(shù)
    method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(
        &rmeta, methodName, methodTypes.size(), methodTypes.constData());
    break;
  case QSIGNAL_CODE://接受者是信號
    method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(
        &rmeta, methodName, methodTypes.size(), methodTypes.constData());
    break;
  }
  //槽的索引為-1，表示無效
  if (method_index_relative < 0) {
    // check for normalized methods
    //將槽進行規(guī)范化處理，并重新轉(zhuǎn)換槽簽名
    tmp_method_name = QMetaObject::normalizedSignature(method);
    method = tmp_method_name.constData();

    methodTypes.clear();
    methodName = QMetaObjectPrivate::decodeMethodSignature(method, methodTypes);
    // rmeta may have been modified above
    //接受者元數(shù)據(jù)對象前面可能被修改過，這里重新獲取
    rmeta = receiver->metaObject();
    //重新獲取槽的索引
    switch (membcode) {
    case QSLOT_CODE:
      method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(
          &rmeta, methodName, methodTypes.size(), methodTypes.constData());
      break;
    case QSIGNAL_CODE:
      method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(
          &rmeta, methodName, methodTypes.size(), methodTypes.constData());
      break;
    }
  }

  //如果還找不到，則說明槽定義有誤，報錯
  if (method_index_relative < 0) {
    err_method_notfound(receiver, method_arg, "connect");
    err_info_about_objects("connect", sender, receiver);
    return QMetaObject::Connection(0);
  }

  //檢查信號和槽的參數(shù)
  if (!QMetaObjectPrivate::checkConnectArgs(signalTypes.size(), signalTypes.constData(),
                       methodTypes.size(), methodTypes.constData())) {
    qWarning("QObject::connect: Incompatible sender/receiver arguments"
         "\n    %s::%s --> %s::%s",
         sender->metaObject()->className(), signal,
         receiver->metaObject()->className(), method);
    return QMetaObject::Connection(0);
  }

  int *types = 0;
  //隊列連接檢查，參數(shù)要是基本類型，或者使用元數(shù)據(jù)注冊
  if ((type == Qt::QueuedConnection)
      && !(types = queuedConnectionTypes(signalTypes.constData(), signalTypes.size()))) {
    return QMetaObject::Connection(0);
  }

#ifndef QT_NO_DEBUG
  //打印調(diào)試信息
  QMetaMethod smethod = QMetaObjectPrivate::signal(smeta, signal_index);
  QMetaMethod rmethod = rmeta->method(method_index_relative + rmeta->methodOffset());
  check_and_warn_compat(smeta, smethod, rmeta, rmethod);
#endif
  QMetaObject::Connection handle = QMetaObject::Connection(QMetaObjectPrivate::connect(
    sender, signal_index, smeta, receiver, method_index_relative, rmeta ,type, types));
  return handle;
}
方法代碼很多很雜，但無非就是檢查信號槽的格式，獲取參數(shù)列表， 最后保存起來

QScopedPointer<QObjectPrivate::Connection> c(new QObjectPrivate::Connection);
c->sender = s; //發(fā)送者對象
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;//靜態(tài)回調(diào)函數(shù)

//在發(fā)送者元數(shù)據(jù)內(nèi)加上連接信息
//信號發(fā)送者的對象內(nèi)存中保存了連接的信息，包括槽的對象，槽地址，連接方式等
QObjectPrivate::get(s)->addConnection(signal_index, c.data());

//因為一個信號可能連接多個槽，這里循環(huán)遍歷鏈表進行調(diào)用
do {
	QObjectPrivate::Connection *c = list->first;
	if (!c) continue;
	// We need to check against last here to ensure that signals added
	// during the signal emission are not emitted in this emission.
	QObjectPrivate::Connection *last = list->last;

	do {
		if (!c->receiver)
			continue;

		QObject * const receiver = c->receiver;
		const bool receiverInSameThread = currentThreadId == receiver->d_func()->threadData->threadId;

		// determine if this connection should be sent immediately or
		// put into the event queue
		//直接連接并且發(fā)送和接受不再一個線程中，或者隊列連接，則放入事件隊列中
		//可知，直接連接并且發(fā)送和接受不在同一個線程，則效果和隊列連接相同
		if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread)
			|| (c->connectionType == Qt::QueuedConnection)) {
			queued_activate(sender, signal_index, c, argv ? argv : empty_argv, locker);
			continue;
#ifndef QT_NO_THREAD
			//阻塞式隊列連接
		} else if (c->connectionType == Qt::BlockingQueuedConnection) {
			locker.unlock();
			//在同一個線程，則報錯
			if (receiverInSameThread) {
				qWarning("Qt: Dead lock detected while activating a BlockingQueuedConnection: "
				"Sender is %s(%p), receiver is %s(%p)",
				sender->metaObject()->className(), sender,
				receiver->metaObject()->className(), receiver);
			}
			QSemaphore semaphore;//資源計數(shù)器，avail為0
			QMetaCallEvent *ev = c->isSlotObject ?
				new QMetaCallEvent(c->slotObj, sender, signal_index, 0, 0, argv ? argv : empty_argv, &semaphore) :
				new QMetaCallEvent(c->method_offset, c->method_relative, c->callFunction, sender, signal_index, 0, 0, argv ? argv : empty_argv, &semaphore);
			//根據(jù)連接信息構(gòu)造一個事件，并添加到接受者的 事件隊列中
			QCoreApplication::postEvent(receiver, ev);
			//信號發(fā)送者的線程阻塞，acquire資源數(shù)為1，>avail(0)，這里阻塞
			//當(dāng)槽執(zhí)行玩之后釋放，這里的avail才會增加，阻塞結(jié)束
			semaphore.acquire();
			locker.relock();
			continue;
#endif
		}

		QConnectionSenderSwitcher sw;

		if (receiverInSameThread) {
			sw.switchSender(receiver, sender, signal_index);
		}
		const QObjectPrivate::StaticMetaCallFunction callFunction = c->callFunction;
		const int method_relative = c->method_relative;
		if (c->isSlotObject) {
			c->slotObj->ref();
			QScopedPointer<QtPrivate::QSlotObjectBase, QSlotObjectBaseDeleter> obj(c->slotObj);
			locker.unlock();
			obj->call(receiver, argv ? argv : empty_argv);

			// Make sure the slot object gets destroyed before the mutex is locked again, as the
			// destructor of the slot object might also lock a mutex from the signalSlotLock() mutex pool,
			// and that would deadlock if the pool happens to return the same mutex.
			obj.reset();

			locker.relock();
		} else if (callFunction && c->method_offset <= receiver->metaObject()->methodOffset()) {
			//we compare the vtable to make sure we are not in the destructor of the object.
			locker.unlock();
			const int methodIndex = c->method();
			if (qt_signal_spy_callback_set.slot_begin_callback != 0)
				qt_signal_spy_callback_set.slot_begin_callback(receiver, methodIndex, argv ? argv : empty_argv);

			callFunction(receiver, QMetaObject::InvokeMetaMethod, method_relative, argv ? argv : empty_argv);

			if (qt_signal_spy_callback_set.slot_end_callback != 0)
				qt_signal_spy_callback_set.slot_end_callback(receiver, methodIndex);
			locker.relock();
		} else {
			const int method = method_relative + c->method_offset;
			locker.unlock();

			if (qt_signal_spy_callback_set.slot_begin_callback != 0) {
				qt_signal_spy_callback_set.slot_begin_callback(receiver,
															method,
															argv ? argv : empty_argv);
			}

			metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv ? argv : empty_argv);

			if (qt_signal_spy_callback_set.slot_end_callback != 0)
				qt_signal_spy_callback_set.slot_end_callback(receiver, method);

			locker.relock();
		}

		if (connectionLists->orphaned)
			break;
	} while (c != last && (c = c->nextConnectionList) != 0);

	if (connectionLists->orphaned)
		break;
} while (list != &connectionLists->allsignals &&
	//start over for all signals;
	((list = &connectionLists->allsignals), true));