c++ Qt信号槽原理

2023-07-05 21:36:03 246

1、说明

使用Qt已经好几年了，一直以为自己懂Qt，熟悉Qt，使用起来很是熟练，无论什么项目，都喜欢用Qt编写。但真正去看Qt的源码，去理解Qt的思想也就近两年的事。

本次就着重介绍一下Qt的核心功能--信号槽机制，相信接触过Qt的人都能很熟悉地使用，甚至，大部分人还能轻松地说出信息槽的几种用法。但是信号槽的核心可不是简单说说就能说清楚的。

那么，本次，就从Qt的源码中讲解一下信号槽的机制。

其实，直到写这篇文章，我也没有完全看明白相关的源码，只是明白了其中的大部分以及使用机制，其中还有很多细节的，留待以后整理。

如果错误还请大家指正。

2、环境以及知识点

Qt版本：Qt5.5.1

系统：windows10

在阅读本文前，希望你能：

熟练使用C++，了解make的编译方法和过程;
熟练使用Qt的信号槽功能，对信号槽的写法以及4和5的区别了如指掌；
QMetaObject元数据系统；
懂一些设计模式，能理解观察者模式；

3、信号槽源码分析

以下将按照SIGNAL/SLOT宏定义连接信号槽的方式做讲解

接下来将会从按照以下的步骤来进行分析：

Qt元数据系统；
moc预编译；
Q_OBJECT宏；
signals和slots关键字以及emit；
SIGNAL()和SLOT()宏；
connect方法；
触发信号；

3.1、Qt的元数据系统

没看过Qt源码的同学可能会对QMetaObject有些陌生，我们打开Qt手册，查看此类的说明，介绍如下：

TheQMetaObjectclasscontainsmeta-informationaboutQtobjects.

TheQtMeta-ObjectSysteminQtisresponsibleforthesignalsandslotsinter-objectcommunicationmechanism,runtimetypeinformation,andtheQtpropertysystem.AsingleQMetaObjectinstanceiscreatedforeachQObjectsubclassthatisusedinanapplication,andthisinstancestoresallthemeta-informationfortheQObjectsubclass.ThisobjectisavailableasQObject::metaObject().

这里是说，QMetaObject包含了Qt的元对象信息。元对象机制类似Java的反射机制。通过继承QObject，并在定义类是添加一定Qt内置宏，能在运行时动态获取Qt的信号槽、类型信息以及相关属性。

一个简答的例子

voidMainWindow::onClickButton()
{
qDebug()<<"onclickbutton";
constQMetaObject*metaObject=this->metaObject();
qDebug()<className();
qDebug()<superClass()->className();

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

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

如上，一个简单的例子，通过QMetaObject，我们得到了该对象的类名、父类名、方法并调用了该方法

怎么样，熟悉Java的小伙伴已经发现了，这不就是Java的反射吗，谁说C++没有反射呢

那么，Qt是如何实现”反射“的呢？答案是使用moc预编译

3.2、moc编译

moc全称Meta-ObjectCompiler，即元对象编译器。我们可以在Qt的安装目录的bin文件下看到moc工具，moc.exe。Qt的构建的时候，会调用该工具生成moc文件，我们在编译目录下看到的moc_xxx.cpp文件就是该工具生成的。

Qt的MinGW版本使用的是qmake进行项目管理，它和cmake功能类似，但没有后者强大。使用qmake生成Makefile后，我们打开Makefile文件，我们可以狠清楚地看到有一个调用moc.exe工具的地方，代码太多，就不列出来了。

此外，我们还发现，并不是所有的代码都会生成moc_xxx.cpp文件的，只有使用了Q_OBJECT宏的类文件，才会生成。没有错，moc工具就是根据Q_OBJECT宏来生成moc_xxx.cpp文件的，而实现“反射”的元数据系统的也是依靠Q_OBJECT的。

到此，我们其实已经能够大概理清qmake项目的构建步骤了。步骤和常用的cmake项目类似，区别就是，qmake生成的Makefile文件种，会写有调用moc工具的指令，以达到moc_xxx.cpp文件的生成。

我们可以使用moc工具手动生成moc_xxx.cpp，使用指令moc.exemainwindow.h，即会在控制台打印moc文件信息，也可以使用-o参数来将生成的内容写入文件，其余参数可以使用moc.exe-h来查看

3.3、Q_OBJECT

我们可以从源代码中查看Q_OBJECT的内容，这里调整一个格式，使用Q_OBJECT宏之后，会在类定义的开头多出以下代码：

public:
Q_OBJECT_CHECK
QT_WARNING_PUSH
Q_OBJECT_NO_OVERRIDE_WARNING
staticconstQMetaObjectstaticMetaObject;
virtualconstQMetaObject*metaObject()const;
virtualvoid*qt_metacast(constchar*);
virtualintqt_metacall(QMetaObject::Call,int,void**);
QT_WARNING_POP
QT_TR_FUNCTIONS
private:
Q_DECL_HIDDEN_STATIC_METACALLstaticvoidqt_static_metacall(QObject*,QMetaObject::Call,int,void**);
structQPrivateSignal{};

可以看到，这里多出几个方法和一些变量

属性staticMetaObject，元数据对象，可以从中获取当前类的元数据；
方法metaObject()，获取元数据对象指针，大多数情况下，返回staticMetaObject指针；
方法qt_metacast()，原数据对象类型转换，转换成指定的类型，使用时一般传入父类的名称字符串；
方法qt_metacall()，执行函数的回调，信号触发；
方法qt_static_metacall()，回调函数，被qt_metacall()调用，内部执行槽；

这里的几个方法都没有实现体，因为实现部分会有moc工具生成，在moc_xxx.cpp文件中可以查看这些方法的实现体

3.4、signals和slots

signals用于声明自定义信号，slots用于声明槽函数，emit用于发送信号，我们可以从源码中查看这三个宏定义

defineslots
definesignalspublic
defineemit

可以看出，这三个宏几乎什么都没有做，signals就是声明所谓的信号是public方法，而slots和emit更是为空，标准C++在编译的时候，根本不受这三个宏的影响，那么它们的用处在哪里呢？在moc工具调用和connect连接的时候。

打开moc_xxx.cpp文件，对比查看信号

signals:
voidclickButton(intvalue);

voidclickButton2();

//SIGNAL0
voidMainWindow::clickButton(int_t1)
{
void*_a[]={Q_NULLPTR,const_cast(reinterpret_cast(&_t1))};
QMetaObject::activate(this,&staticMetaObject,0,_a);
}

//SIGNAL1
voidMainWindow::clickButton2()
{
QMetaObject::activate(this,&staticMetaObject,1,Q_NULLPTR);
}

其实，信号就是方法，而emitclickButton()发送信号，就是调用clickButton()方法，换言之，触发信号，就算不要emit也无妨

3.5、SIGNAL()和SLOT()

查看源码

#defineSLOT(a)qFlagLocation("1"#aQLOCATION)
#defineSIGNAL(a)qFlagLocation("2"#aQLOCATION)

qFlagLocation()源码如下：

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

store()方法

voidstore(constchar*method)
{locations[idx++%Count]=method;}

所以SIGNAL(clickButton())宏展开为qFlagLocation("2"clickButton(int)QLOCATION)

SLOT()同理，这里的1和2，最后会添加到信号槽的前面，其实是为了区分信号和槽，源码中还有一个0在METHOD()宏

qFlagLocation方法的作用是将信号槽转换成字符串保存起来，store方法中，locations是个二维数组，而idx每次都加一，保证信号和槽的不同的方法存储在不同的数组中。

我们也可以在代码中打印出来看下：

qDebug()<
3.6、connect方法


最后，就是最关键的connect方法，做了一些简单的注释
QMetaObject::ConnectionQObject::connect(constQObject*sender,constchar*signal,
constQObject*receiver,constchar*method,
Qt::ConnectionTypetype)
{
if(sender==0||receiver==0||signal==0||method==0){
qWarning("QObject::connect:Cannotconnect%s::%sto%s::%s",
sender?sender->metaObject()->className():"(null)",
(signal&&*signal)?signal+1:"(null)",
receiver?receiver->metaObject()->className():"(null)",
(method&&*method)?method+1:"(null)");
returnQMetaObject::Connection(0);
}
QByteArraytmp_signal_name;

if(!check_signal_macro(sender,signal,"connect","bind"))
returnQMetaObject::Connection(0);
constQMetaObject*smeta=sender->metaObject();//获取发送者的元数据对象
constchar*signal_arg=signal;//信号
++signal;//skipcode
QArgumentTypeArraysignalTypes;//信号参数类型数组
Q_ASSERT(QMetaObjectPrivate::get(smeta)->revision>=7);
//信号转换为签名，并得到信号参数类型数组
QByteArraysignalName=QMetaObjectPrivate::decodeMethodSignature(signal,signalTypes);
//找到信号索引
intsignal_index=QMetaObjectPrivate::indexOfSignalRelative(
&smeta,signalName,signalTypes.size(),signalTypes.constData());
//小于0表示，表示信号索引有问题
if(signal_index<0){
//checkfornormalizedsignatures
//将信号重新规范化，再进行上面的签名转换，并重新得到索引
tmp_signal_name=QMetaObject::normalizedSignature(signal-1);
signal=tmp_signal_name.constData()+1;

//重新进行签名转换，并得到参数类型列表
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);
returnQMetaObject::Connection(0);
}
//根据当前信号的索引找到最原始的信号的索引，因为信号是可以被继承，这里找的祖先信号
signal_index=QMetaObjectPrivate::originalClone(smeta,signal_index);
signal_index+=QMetaObjectPrivate::signalOffset(smeta);//信号的索引再加上信号的偏移量

QByteArraytmp_method_name;
//提取槽的编码，应该是QSLOT_CODE或者QSIGNAL_CODE，用于判断槽是信号还是方法
intmembcode=extract_code(method);

//检查槽编码，槽可以是槽函数或者信号，初次以为，都无效
if(!check_method_code(membcode,receiver,method,"connect"))
returnQMetaObject::Connection(0);
constchar*method_arg=method;
++method;//skipcode

QArgumentTypeArraymethodTypes;
//转换槽签名，并获取槽的参数类型列表
QByteArraymethodName=QMetaObjectPrivate::decodeMethodSignature(method,methodTypes);
constQMetaObject*rmeta=receiver->metaObject();//获取接受者的元数据对象
intmethod_index_relative=-1;
Q_ASSERT(QMetaObjectPrivate::get(rmeta)->revision>=7);
switch(membcode){
caseQSLOT_CODE://接受者是槽函数
method_index_relative=QMetaObjectPrivate::indexOfSlotRelative(
&rmeta,methodName,methodTypes.size(),methodTypes.constData());
break;
caseQSIGNAL_CODE://接受者是信号
method_index_relative=QMetaObjectPrivate::indexOfSignalRelative(
&rmeta,methodName,methodTypes.size(),methodTypes.constData());
break;
}
//槽的索引为-1，表示无效
if(method_index_relative<0){
//checkfornormalizedmethods
//将槽进行规范化处理，并重新转换槽签名
tmp_method_name=QMetaObject::normalizedSignature(method);
method=tmp_method_name.constData();

methodTypes.clear();
methodName=QMetaObjectPrivate::decodeMethodSignature(method,methodTypes);
//rmetamayhavebeenmodifiedabove
//接受者元数据对象前面可能被修改过，这里重新获取
rmeta=receiver->metaObject();
//重新获取槽的索引
switch(membcode){
caseQSLOT_CODE:
method_index_relative=QMetaObjectPrivate::indexOfSlotRelative(
&rmeta,methodName,methodTypes.size(),methodTypes.constData());
break;
caseQSIGNAL_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);
returnQMetaObject::Connection(0);
}

//检查信号和槽的参数
if(!QMetaObjectPrivate::checkConnectArgs(signalTypes.size(),signalTypes.constData(),
methodTypes.size(),methodTypes.constData())){
qWarning("QObject::connect:Incompatiblesender/receiverarguments"
"\n%s::%s-->%s::%s",
sender->metaObject()->className(),signal,
receiver->metaObject()->className(),method);
returnQMetaObject::Connection(0);
}

int*types=0;
//队列连接检查，参数要是基本类型，或者使用元数据注册
if((type==Qt::QueuedConnection)
&&!(types=queuedConnectionTypes(signalTypes.constData(),signalTypes.size()))){
returnQMetaObject::Connection(0);
}

#ifndefQT_NO_DEBUG
//打印调试信息
QMetaMethodsmethod=QMetaObjectPrivate::signal(smeta,signal_index);
QMetaMethodrmethod=rmeta->method(method_index_relative+rmeta->methodOffset());
check_and_warn_compat(smeta,smethod,rmeta,rmethod);
#endif
QMetaObject::Connectionhandle=QMetaObject::Connection(QMetaObjectPrivate::connect(
sender,signal_index,smeta,receiver,method_index_relative,rmeta,type,types));
returnhandle;
}
方法代码很多很杂，但无非就是检查信号槽的格式，获取参数列表，最后保存起来

QScopedPointerc(newQObjectPrivate::Connection);
c->sender=s;//发送者对象
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;//静态回调函数

//在发送者元数据内加上连接信息
//信号发送者的对象内存中保存了连接的信息，包括槽的对象，槽地址，连接方式等
QObjectPrivate::get(s)->addConnection(signal_index,c.data());
3.7、触发信号


这时候再回过头来看3.4中的信号触发，我们知道，emit信号就是调用moc文件中的方法，方法的核心就是QMetaObject::activate()
直接看该方法中调用槽函数的一段
//因为一个信号可能连接多个槽，这里循环遍历链表进行调用
do{
	QObjectPrivate::Connection*c=list->first;
	if(!c)continue;
	//Weneedtocheckagainstlastheretoensurethatsignalsadded
	//duringthesignalemissionarenotemittedinthisemission.
	QObjectPrivate::Connection*last=list->last;

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

		QObject*constreceiver=c->receiver;
		constboolreceiverInSameThread=currentThreadId==receiver->d_func()->threadData->threadId;

		//determineifthisconnectionshouldbesentimmediatelyor
		//putintotheeventqueue
		//直接连接并且发送和接受不再一个线程中，或者队列连接，则放入事件队列中
		//可知，直接连接并且发送和接受不在同一个线程，则效果和队列连接相同
		if((c->connectionType==Qt::AutoConnection&&!receiverInSameThread)
			||(c->connectionType==Qt::QueuedConnection)){
			queued_activate(sender,signal_index,c,argv?argv:empty_argv,locker);
			continue;
#ifndefQT_NO_THREAD
			//阻塞式队列连接
		}elseif(c->connectionType==Qt::BlockingQueuedConnection){
			locker.unlock();
			//在同一个线程，则报错
			if(receiverInSameThread){
				qWarning("Qt:DeadlockdetectedwhileactivatingaBlockingQueuedConnection:"
				"Senderis%s(%p),receiveris%s(%p)",
				sender->metaObject()->className(),sender,
				receiver->metaObject()->className(),receiver);
			}
			QSemaphoresemaphore;//资源计数器，avail为0
			QMetaCallEvent*ev=c->isSlotObject?
				newQMetaCallEvent(c->slotObj,sender,signal_index,0,0,argv?argv:empty_argv,&semaphore):
				newQMetaCallEvent(c->method_offset,c->method_relative,c->callFunction,sender,signal_index,0,0,argv?argv:empty_argv,&semaphore);
			//根据连接信息构造一个事件，并添加到接受者的事件队列中
			QCoreApplication::postEvent(receiver,ev);
			//信号发送者的线程阻塞，acquire资源数为1，>avail(0)，这里阻塞
			//当槽执行玩之后释放，这里的avail才会增加，阻塞结束
			semaphore.acquire();
			locker.relock();
			continue;
#endif
		}

		QConnectionSenderSwitchersw;

		if(receiverInSameThread){
			sw.switchSender(receiver,sender,signal_index);
		}
		constQObjectPrivate::StaticMetaCallFunctioncallFunction=c->callFunction;
		constintmethod_relative=c->method_relative;
		if(c->isSlotObject){
			c->slotObj->ref();
			QScopedPointerobj(c->slotObj);
			locker.unlock();
			obj->call(receiver,argv?argv:empty_argv);

			//Makesuretheslotobjectgetsdestroyedbeforethemutexislockedagain,asthe
			//destructoroftheslotobjectmightalsolockamutexfromthesignalSlotLock()mutexpool,
			//andthatwoulddeadlockifthepoolhappenstoreturnthesamemutex.
			obj.reset();

			locker.relock();
		}elseif(callFunction&&c->method_offset<=receiver->metaObject()->methodOffset()){
			//wecomparethevtabletomakesurewearenotinthedestructoroftheobject.
			locker.unlock();
			constintmethodIndex=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{
			constintmethod=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&&
	//startoverforallsignals;
	((list=&connectionLists->allsignals),true));
由上面代码，我们大概可以理解信号槽的几种连接方式：

默认连接并且信号槽的对象不在同一个线程中，则效果和队列连接类似；
阻塞时队列连接，信号和槽对象不同处于同一个线程中；
Qt使用QSemaphore来实现阻塞式的槽函数调用；



4、小结


本次的源码因为种种原因，看的不是很详细，但是理解Qt的信号槽机制绰绰有余了

Qt自带的元数据系统利用C++的宏等特性实现反射机制；
利用元数据系统，在连接信号槽是将槽的信息（接收对象、槽方法、参数列表、连接方式等）保存在信号的元数据中；
信号也是方法，方法体有moc工具生成，方法内获取该信号连接的所有槽信息，并依序执行；

直到这里，信号槽的逻辑已经显而易见了，它就是一个变种的观察者模式，槽的信息保存在信号对象中也就是设置回调函数，触发信号也就是执行回调函数，只是Qt库将其中的各种操作细节封装起来了，所以，使用起来，不去关注设计模式的细节，也就容易很多了。不得不说，无论是从设计思路，还是开发技巧上看，Qt的开发者真的很牛叉。
5、第三方信号槽库


信号槽机制是Qt首创，但不是其独有，其他各类C++流行框架也都是互相借鉴，C++标准库的预备役的boost中也有信号槽机制的实现。如果平时开发中需要用到信号槽机制，但是又不想引入这些庞大的类库，可以使用轻量级别的信号槽库：http://sigslot.sourceforge.net，该库不详细介绍，有兴趣的小伙伴自己学习把。
以上就是c++Qt信号槽原理的详细内容，更多关于c++Qt信号槽的资料请关注毛票票其它相关文章！

c++ Qt信号槽原理

1、说明

2、环境以及知识点

3、信号槽源码分析

3.1、Qt的元数据系统

3.2、moc编译

3.3、Q_OBJECT

3.4、signals和slots

3.5、SIGNAL()和SLOT()

3.6、connect方法

3.7、触发信号

4、小结

5、第三方信号槽库

热门推荐

随机推荐