繼續 詳解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 信號機制 （下篇）的內容介紹完了，希望本文對你有所幫助！