QT中關于信號與槽機制的實現原理，需要用到的類，在本文中一一展現，代碼較多，內容如下：

一、每個對象都有一個相應的紀錄該對象的元對象

關于元對象的類：

QMetaObject類：

  /*******************生成元對象需要的輸入參數*****************/  
//類名  
const char * const class_name,  
//父類名  
QMetaObject *superclass,  
//記錄slot 信息  
const QMetaData * const slot_data,   
//記錄槽的個數  
int n_slots,  
//記錄signal 信息  
const QMetaData * const signal_data,  
//記錄信號的個數  
int n_signals  
/******************* 元對象類提供的方法**************************/  
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 );  
static bool hasMetaObject( const char *class_name ); 

QMetaData類：

//記錄元對象數據for 信號與槽  
struct QMetaData           
                     {                                   
const char *name;  //名稱  
const QUMethod* method; //詳細描述信息  
enum Access { Private, Protected, Public };  
Access access; //訪問權限  
 }; 

二、QObject類實現了信號與槽機制

它利用元對象紀錄的信息，實現了信號與槽機制

（1）信號與槽建立連接的實現

接口函數：

//連接  
//參數（發送對象，信號，接收對象，處理信號的信號/槽）  
static bool  connect( const QObject *sender, const char *signal,  
const QObject *receiver, const char *member );  
bool connect(const QObject *sender, const char *signal,  
const char *member ) const;  
static bool  disconnect( const QObject *sender, const char *signal,  
const QObject *receiver, const char *member );  
bool disconnect(const char *signal=0,  
const QObject *receiver=0, const char *member=0 );  
bool disconnect( const QObject *receiver, const char *member=0 );  
//連接的內部實現  
//（發送對象，信號的索引，接收對象，處理信號的類型，處理信號信號/槽的索引）  
static void connectInternal(const QObject *sender, int signal_index,  
const QObject *receiver, int membcode, int member_index );  
static bool disconnectInternal(const QObject *sender, int signal_index,  
const QObject *receiver, int membcode, int member_index ); 

信號與槽連接的實現原理：

①階段  
bool QObject::connect( const QObject *sender,//發送對象        
const char *signal,//信號  
 const QObject *receiver, //接收對象  
const char *member //槽  
                                )  
       {  
 //檢查發送對象，信號，接收對象，槽不為null  
if ( sender == 0 || receiver == 0 || signal == 0 || member == 0 ) {        
                     return FALSE;  
           }  
//獲取發送對象的元對象  
QMetaObject *smeta = sender->metaObject();  
//檢查信號  
if ( !check_signal_macro( sender, signal, "connect", "bind" ) )  
return FALSE;     
//獲取信號的索引  
int signal_index = smeta->findSignal( signal, TRUE );  
if ( signal_index < 0 ) {                // normalize and retry  
nw_signal = qt_rmWS( signal-1 ); // remove whitespace  
signal = nw_signal.data()+1;         // skip member type code  
signal_index = smeta->findSignal( signal, TRUE );  
            }  
           //如果信號不存在，則退出  
           if ( signal_index < 0  ) {                    // no such signal  
                     return FALSE;  
           }  
           //獲取信號的元數據對象  
const QMetaData *sm = smeta->signal( signal_index, TRUE );  
//獲取信號名字  
signal = sm->name;         
 //獲取處理信號的類型（是信號/槽）  
int membcode = member[0] - '0';        // get member code  
              //發送信號對象  
QObject *s = (QObject *)sender;        // we need to change them  
          //接收信號對象  
QObject *r = (QObject *)receiver;             //   internally  
           //獲取接收對象的元對象  
           QMetaObject *rrmeta = r->metaObject();  
           int member_index = -1;  
           switch ( membcode ) {                // get receiver member  
case QSLOT_CODE://如果是槽  
//獲取槽索引  
member_index = rmeta->findSlot( member, TRUE );  
if ( member_index < 0 ) {            // normalize and retry  
nw_member = qt_rmWS(member);     // remove whitespace  
 member = nw_member;  
 member_index = rmeta->findSlot( member, TRUE );  
                         }  
                         break;  
                     case QSIGNAL_CODE://如果是信號  
                            //獲取信號索引  
 member_index = rmeta->findSignal( member, TRUE );  
 if ( member_index < 0 ) {           // normalize and retry  
nw_member = qt_rmWS(member);     // remove whitespace  
member = nw_member;  
member_index = rmeta->findSignal( member, TRUE );  
                         }  
                         break;  
           }  
           /如果接收對象不存在相應的信號或槽，則退出  
           if ( member_index < 0  ) {  
                     return FALSE;  
           }  
//檢查連接的參數(發送的信號，接收對象，處理信號的槽或信號)  
if ( !s->checkConnectArgs(signal,receiver,member) ) {  
                     return FALSE;  
           } else {  
                //獲取處理信號的元數據對象  
const QMetaData *rm = membcode == QSLOT_CODE ?  
rmeta->slot( member_index, TRUE ) :  
rmeta->signal( member_index, TRUE );  
                     if ( rm ) {            
                         //建立連接  
                            //(發送信號的對象，信號的索引，接收信號的對象，  
                              處理信號的類型，處理信號的索引)  
                        connectInternal( sender, signal_index, receiver, membcode, member_index );  
                   }  
              }  
           return TRUE;  
       }  
 ②階段  
       //建立連接  
       //(發送信號的對象，信號的索引，接收信號的對象，處理信號的類型，處理信號的索引)  
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;  
    //如果發送對象的連接查詢表為null，則建立  
    if ( !s->connections ) {                // create connections lookup table  
       s->connections = new QSignalVec( signal_index+1 );  
       Q_CHECK_PTR( s->connections );  
      s->connections->setAutoDelete( TRUE );  
    }  
    //獲取發送對象的相應信號的連接列表  
 
    QConnectionList *clist = s->connections->at( signal_index );  
 
    if ( !clist ) {                         // create receiver list  
       clist = new QConnectionList;  
       Q_CHECK_PTR( clist );  
       clist->setAutoDelete( TRUE );  
       s->connections->insert( signal_index, clist );  
    }  
    QMetaObject *rrmeta = r->metaObject();  
   const QMetaData *rm = 0;  
    switch ( membcode ) {                // get receiver member  
       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 );  
    Q_CHECK_PTR( c );  
   //把連接添加到發送對象的連接列表中  
    clist->append( c );  
    //判斷接收對象的發送對象列表是否為null  
    if ( !r->senderObjects )               // create list of senders  
           {  
          //建立接收對象的發送對象列表  
       r->senderObjects = new QSenderObjectList;  
          }  
    //把發送對象添加到發送對象列表中  
    r->senderObjects->append( s );           // add sender to list  
       } 

（2）信號發生時激活的操作函數。 激活slot的方法

接口：
 void QObject::activate_signal( int signal )  
       {  
       #ifndef QT_NO_PRELIMINARY_SIGNAL_SPY  
           if ( qt_preliminary_signal_spy ) {  
                  //信號沒有被阻塞  
                  //信號>=0  
                  //連接列表不為空，或者信號對應的連接存在  
              if ( !signalsBlocked() && signal >= 0 &&  
                ( !connections || !connections->at( signal ) ) ) {  
                 //  
                 QUObject o[1];  
                  qt_spy_signal( this, signal, o );  
                  return;  
              }  
    }  
       #endif  
    if ( !connections || signalsBlocked() || signal < 0 )  
       return;  
    //獲取信號對應的連接列表  
    QConnectionList *clist = connections->at( signal );  
    if ( !clist )  
       return;  
   QUObject o[1];  
    //  
    activate_signal( clist, o );  
}  
 
void QObject::activate_signal( QConnectionList *clist, QUObject *o )  
{  
    if ( !clist )  
       return;  
#ifndef QT_NO_PRELIMINARY_SIGNAL_SPY  
    if ( qt_preliminary_signal_spy )  
       qt_spy_signal( this, connections->findRef( clist), o );  
#endif  
    QObject *object;  
       //發送對象列表  
    QSenderObjectList* sol;  
       //舊的發送對象  
    QObject* oldSender = 0;  
       //連接  
    QConnection *c;  
    if ( clist->count() == 1 ) { // save iterator  
           //獲取連接  
       c = clist->first();  
       //  
       object = c->object();  
       //獲取發送對象列表  
       sol = object->senderObjects;  
       if ( sol ) {  
              //獲取舊的發送對象  
          oldSender = sol->currentSender;  
              //  
           sol->ref();  
              //設置新的發送對象  
           sol->currentSender = this;  
       }  
       if ( c->memberType() == QSIGNAL_CODE )//如果是信號，則發送出去  
           object->qt_emit( c->member(), o );  
       else  
           object->qt_invoke( c->member(), o );//如果是槽，則執行  
       //       
       if ( sol ) {  
              //設置恢復為舊的發送對象  
           sol->currentSender = oldSender;  
           if ( sol->deref() )  
              delete sol;  
       }  
    } else {  
       QConnection *cd = 0;  
       QConnectionListIt it(*clist);  
       while ( (c=it.current()) ) {  
          ++it;  
          if ( c == cd )  
             continue;  
           ccd = c;  
           object = c->object();  
           //操作前設置當前發送對象  
           sol = object->senderObjects;  
           if ( sol ) {  
              oldSender = sol->currentSender;  
              sol->ref();  
              sol->currentSender = this;  
          }  
           //如果是信號，則發送出去  
           if ( c->memberType() == QSIGNAL_CODE ){  
              object->qt_emit( c->member(), o );  
           }  
           //如果是槽，則執行  
           else{  
              object->qt_invoke( c->member(), o );  
           }  
           //操作后恢復當前發送對象  
           if (sol ) {  
              sol->currentSender = oldSender;  
              if ( sol->deref() )  
                  delete sol;  
           }  
       }  
    }  
} 

【編輯推薦】

Qt的插件機制

QT的信號與槽機制

Qt網絡之獲取本機網絡信息

淺談自動化測試工具 QTP腳本的重用

Qt和KDE在未來將面臨新的挑戰和機遇