详解QT 信号机制（下篇）-qt信号槽机制原理

继续详解QT 信号机制（上篇）的内容接续介绍，本节介绍的是详解QT 信号机制 （下篇），以下是QMetaObject的定义（为了浏览方便，删除了一部分次要代码）：

class Q_EXPORT QMetaObject  
{  
public:  
QMetaObject( const char * const class_name, QMetaObject *superclass,  
const QMetaData * const slot_data, int n_slots,  
const QMetaData * const signal_data, int n_signals);  
virtual ~QMetaObject();  
int numSlots( bool super = FALSE ) const; /* 反应槽的数量 */  
int numSignals( bool super = FALSE ) const; /* 信号的数量 */  
int findSlot( const char *, bool super = FALSE ) const;  
/* 根据反应槽的名称找到其在列表中的索引 */  
int findSignal( const char *, bool super = FALSE ) const;  
/* 根据信号的名称找到其在列表中的索引 */  
const QMetaData *slot( int index, bool super = FALSE ) const;  
/* 根据索引取得反应槽的数据 */  
const QMetaData *signal( int index, bool super = FALSE ) const;  
/* 根据索引取得信号的数据 */  
QStrList slotNames( bool super = FALSE ) const;  
/* 取得反应槽列表 */  
QStrList signalNames( bool super = FALSE ) const;  
/* 取得信号列表 */  
int slotOffset() const;  
int signalOffset() const;  
static QMetaObject *metaObject( const char *class_name );  
private:  
QMemberDict *init( const QMetaData *, int );  
const QMetaData *slotData; /* 反应槽数据指针 */  
QMemberDict *slotDict; /* 反应槽数据字典指针 */  
const QMetaData *signalData; /* 信号数据指针*/  
QMemberDict *signalDict; /* 信号数据字典指针*/  
int signaloffset;  
int slotoffset;  
};

再看一下QObject中connect的实现。剥去粗枝，函数中便露出一个更细化的函数：connectInternal，它又做了哪些工作呢？让我们看一下：

void QObject::connectInternal( const QObject *sender, int signal_index,  
const QObject *receiver,  
int membcode, int member_index )  
{  
QObject *s = (QObject*)sender;  
QObject *r = (QObject*)receiver;  
if ( !s->connections ) {  
/* 如果某个对象有信号或反应槽但没有建立相互连接是不会建立连接列表的，这样可减少一些无谓的资源消耗 */  
s->connections = new QSignalVec( 7 );  
s->connections->setAutoDelete( TRUE );  
/* 无连接时，连接列表将被自动删除 */  
}  
QConnectionList *clist = s->connections->at( signal_index );  
if ( !clist ) {  
/* 建立与信号源对象中某一个信号所对应的接收对象的列表 */  
clist = new QConnectionList;  
clist->setAutoDelete( TRUE );  
s->connections->insert( signal_index, clist );  
}  
QMetaObject *rrmeta = r->metaObject();  
switch ( membcode ) {  
/* 取得信号或反应槽的数据指针 */  
case QSLOT_CODE:  
rm = rmeta->slot( member_index, TRUE );  
break;  
case QSIGNAL_CODE:  
rm = rmeta->signal( member_index, TRUE );  
break;  
}  
QConnection *c = new QConnection( r, member_index,  
rm ? rm->name : "qt_invoke", membcode );  
/* 创建一个新的信号/反应槽连接 */  
clist->append( c ); /* 信号源端加入这一对连接 */  
if ( !r->senderObjects ) {  
/* 类似于信号源端，反应槽端的连接列表也是动态创建的 */  
r->senderObjects = new QObjectList;  
}  
r->senderObjects->append( s ); /* 反应槽端加入这一对连接 */  
}

到此，信号与反应槽的连接已建立完毕，那么信号产生时又是如何触发反应槽的呢？从QObject的定义中可以看出其有多个activate_signal的成员函数，这些函数都是protected的，也即只有其自身或子类才可以使用。看一下它的实现：

void QObject::activate_signal( QConnectionList *clist, QUObject *o )  
{  
if ( !clist ) /* 有效性检查 */  
return;  
QObject *object;  
QConnection *c;  
if ( clist->count() == 1 ) {  
/* 对某一个对象的一个具体信号来说，一般只有一种反应槽与之相连，这样事先判断一下可以加快处理速度 */  
c = clist->first();  
object = c->object();  
sigSender = this;  
if ( c->memberType() == QSIGNAL_CODE )  
object->qt_emit( c->member(), o ); /* 信号级连 */  
else  
object->qt_invoke( c->member(), o );/* 调用反应槽函数 */  
} else {  
QConnectionListIt it(*clist);  
while ( (c=it.current()) ) { /* 有多个连接时，逐一扫描 */  
++it;  
object = c->object();  
sigSender = this;  
if ( c->memberType() == QSIGNAL_CODE )  
object->qt_emit( c->member(), o ); /* 信号级连 */  
else  
object->qt_invoke( c->member(), o ); /* 调用反应槽函数 */  
}  
}  
}

至此我们已经可以基本了解Qt中信号/反应槽的流程。我们再看一下Qt为此而新增的语法：三个关键字：slots、signals和emit，三个宏：SLOT()、SIGNAL()和Q_OBJECT。在头文件qobjectdefs.h中，我们可以看到这些新增语法的定义如下：

#define slots // slots: in class  
#define signals protected // signals: in class  
#define emit // emit signal  
#define SLOT(a) "1"#a  
#define SIGNAL(a) "2"#a

由此可知其实三个关键字没有做什么事情，而SLOT()和SIGNAL()宏也只是在字符串前面简单地加上单个字符，以便程序仅从名称就可以分辨谁是信号、谁是反应槽。中间编译程序moc.exe则可以根据这些关键字和宏对相应的函数进行“翻译”，以便在C++编译器中编译。剩下一个宏Q_OBJECT比较复杂，它的定义如下：

#define Q_OBJECT ＼  
publi ＼  
virtual QMetaObject *metaObject() const { ＼  
return staticMetaObject(); ＼  
}  
＼  
virtual const char *className() const; ＼  
virtual void* qt_cast( const char* ); ＼  
virtual bool qt_invoke( int, QUObject* ); ＼  
virtual bool qt_emit( int, QUObject* ); ＼  
QT_PROP_FUNCTIONS  
＼  
static QMetaObject* staticMetaObject(); ＼  
QObject* qObject() { return (QObject*)this; } ＼  
QT_TR_FUNCTIONS  
＼  
private: ＼  
static QMetaObject *metaObj;

从定义中可以看出该宏的作用有两个：一是对与自己相关的QMetaObject中间类操作进行声明，另一个是对信号的释放操作和反应槽的激活操作进行声明。当moc.exe对头文件进行预编译之后，将会产生一个可供C++编译器编译的源文件。以上述的Demo类为例，假设它的代码文件分别为d e m o . h和d e m o . c p p ，预编译后将产生

moc_demo.cpp，其主要内容如下：

QMetaObject *Demo::metaObj = 0;  
void Demo::initMetaObject()  
{  
if ( metaObj )  
return;  
if ( strcmp(QObject::className(), "QObject") != 0 )  
badSuperclassWarning("Demo","QObject");  
(void) staticMetaObject();  
}  
QMetaObject* Demo::staticMetaObject()  
{  
if ( metaObj )  
return metaObj;  
(void) QObject::staticMetaObject();  
typedef void(Demo::*m1_t0)(int);  
m1_t0 v1_0 = Q_AMPERSAND Demo::setValue; /* 定位反应槽的入口 */  
QMetaData *slot_tbl = QMetaObject::new_metadata(1);  
/* 新建一个反应槽数据 */  
QMetaData::Access *slot_tbl_access = QMetaObject::new_metaaccess(1);  
slot_tbl[0].name = "setValue(int)"; /* 反应槽名称 */  
slot_tbl[0].ptr = *((QMember*)&v1_0);  
/* 通过反应槽名称可以找到反应槽的入口指针 */  
slot_tbl_access[0] = QMetaData::Public; /* 权限类型 */  
typedef void(Demo::*m2_t0)(int);  
m2_t0 v2_0 = Q_AMPERSAND Demo::valueChanged; /* 定位信号的入口 */  
QMetaData *signal_tbl = QMetaObject::new_metadata(1); /* 新建信号数据 */  
signal_tbl[0].name = "valueChanged(int)"; /* 信号名称 */  
signal_tbl[0].ptr = *((QMember*)&v2_0);  
/* 通过信号名称可以找到信号的入口指针 */  
metaObj = QMetaObject::new_metaobject(  
/* 创建一个与demo类相关的QMetaObject对象 */  
"Demo", "QObject",  
slot_tbl, 1,  
signal_tbl, 1,  
0, 0 );  
metaObj->set_slot_access( slot_tbl_access ); /* 设置权限 */  
return metaObj;  
}  
// 有信号时即激活对应的反应槽或另一个信号  
void Demo::valueChanged( int t0 )  
{  
activate_signal( "valueChanged(int)", t0 );  
}

该文件中既没有Qt特有的关键字，也没有特殊的宏定义，完全符合普通的C++语法，因此可以顺利编译和链接。

小结：关于详解QT 信号机制 （下篇）的内容介绍完了，希望本文对你有所帮助！

详解QT 信号机制 （下篇）

详解QT 信号机制（下篇）