QT中关于信号与槽机制的实现原理

移动开发
本文介绍的内容是QT中关于信号与槽机制的实现原理,每个对象都有一个相应的纪录该对象的元对象,关于元对象的类在本文中有所介绍。

QT中关于信号与槽机制的实现原理,需要用到的类,在本文中一一展现,代码较多,内容如下:

一、每个对象都有一个相应的纪录该对象的元对象

关于元对象的类:

QMetaObject类:

  1.   /*******************生成元对象需要的输入参数*****************/  
  2. //类名  
  3. const char * const class_name,  
  4. //父类名  
  5. QMetaObject *superclass,  
  6. //记录slot 信息  
  7. const QMetaData * const slot_data,   
  8. //记录槽的个数  
  9. int n_slots,  
  10. //记录signal 信息  
  11. const QMetaData * const signal_data,  
  12. //记录信号的个数  
  13. int n_signals  
  14. /******************* 元对象类提供的方法**************************/  
  15. int   numSlots( bool super = FALSE ) const;//返回槽的个数  
  16. int   numSignals( bool super = FALSE ) const;//返回信号的个数  
  17. int   findSlot( const char *, bool super = FALSE ) const;//查找槽  
  18. int   findSignal( const char *, bool super = FALSE ) const;//查找信号  
  19.  //返回指定位置的槽  
  20. const QMetaData *slot( int index, bool super = FALSE ) const;  
  21.  //返回指定位置的信号  
  22. const QMetaData *signal( int index, bool super = FALSE ) const;  
  23. //所有槽名字的列表  
  24. QStrList  slotNames( bool super = FALSE ) const;  
  25. //所有信号名字的列表  
  26. QStrList  signalNames( bool super = FALSE ) const;  
  27. //槽的起始索引  
  28. int   slotOffset() const;  
  29. //信号的起始索引  
  30. int   signalOffset() const;  
  31. /***********************两个获取类的元对象的方法*****************/  
  32. static QMetaObject *metaObject( const char *class_name );  
  33. static bool hasMetaObject( const char *class_name ); 

QMetaData类:

  1. //记录元对象数据for 信号与槽  
  2. struct QMetaData           
  3.                      {                                   
  4. const char *name;  //名称  
  5. const QUMethod* method; //详细描述信息  
  6. enum Access { Private, Protected, Public };  
  7. Access access; //访问权限  
  8.  }; 

二、QObject类实现了信号与槽机制

它利用元对象纪录的信息,实现了信号与槽机制

(1)信号与槽建立连接的实现

接口函数:

  1. //连接  
  2. //参数(发送对象,信号,接收对象,处理信号的信号/槽)  
  3. static bool  connect( const QObject *sender, const char *signal,  
  4. const QObject *receiver, const char *member );  
  5. bool connect(const QObject *sender, const char *signal,  
  6. const char *member ) const;  
  7. static bool  disconnect( const QObject *sender, const char *signal,  
  8. const QObject *receiver, const char *member );  
  9. bool disconnect(const char *signal=0,  
  10. const QObject *receiver=0, const char *member=0 );  
  11. bool disconnect( const QObject *receiver, const char *member=0 );  
  12. //连接的内部实现  
  13. //(发送对象,信号的索引,接收对象,处理信号的类型,处理信号信号/槽的索引)  
  14. static void connectInternal(const QObject *sender, int signal_index,  
  15. const QObject *receiver, int membcode, int member_index );  
  16. static bool disconnectInternal(const QObject *sender, int signal_index,  
  17. const QObject *receiver, int membcode, int member_index ); 

信号与槽连接的实现原理:

  1. ①阶段  
  2. bool QObject::connect( const QObject *sender,//发送对象        
  3. const char *signal,//信号  
  4.  const QObject *receiver, //接收对象  
  5. const char *member //槽  
  6.                                 )  
  7.        {  
  8.  //检查发送对象,信号,接收对象,槽不为null  
  9. if ( sender == 0 || receiver == 0 || signal == 0 || member == 0 ) {        
  10.                      return FALSE;  
  11.            }  
  12. //获取发送对象的元对象  
  13. QMetaObject *smeta = sender->metaObject();  
  14. //检查信号  
  15. if ( !check_signal_macro( sender, signal, "connect", "bind" ) )  
  16. return FALSE;     
  17. //获取信号的索引  
  18. int signal_index = smeta->findSignal( signal, TRUE );  
  19. if ( signal_index < 0 ) {                // normalize and retry  
  20. nw_signal = qt_rmWS( signal-1 ); // remove whitespace  
  21. signal = nw_signal.data()+1;         // skip member type code  
  22. signal_index = smeta->findSignal( signal, TRUE );  
  23.             }  
  24.            //如果信号不存在,则退出  
  25.            if ( signal_index < 0  ) {                    // no such signal  
  26.                      return FALSE;  
  27.            }  
  28.            //获取信号的元数据对象  
  29. const QMetaData *sm = smeta->signal( signal_index, TRUE );  
  30. //获取信号名字  
  31. signal = sm->name;         
  32.  //获取处理信号的类型(是信号/槽)  
  33. int membcode = member[0] - '0';        // get member code  
  34.               //发送信号对象  
  35. QObject *s = (QObject *)sender;        // we need to change them  
  36.           //接收信号对象  
  37. QObject *r = (QObject *)receiver;             //   internally  
  38.            //获取接收对象的元对象  
  39.            QMetaObject *rrmeta = r->metaObject();  
  40.            int member_index = -1;  
  41.            switch ( membcode ) {                // get receiver member  
  42. case QSLOT_CODE://如果是槽  
  43. //获取槽索引  
  44. member_index = rmeta->findSlot( member, TRUE );  
  45. if ( member_index < 0 ) {            // normalize and retry  
  46. nw_member = qt_rmWS(member);     // remove whitespace  
  47.  member = nw_member;  
  48.  member_index = rmeta->findSlot( member, TRUE );  
  49.                          }  
  50.                          break;  
  51.                      case QSIGNAL_CODE://如果是信号  
  52.                             //获取信号索引  
  53.  member_index = rmeta->findSignal( member, TRUE );  
  54.  if ( member_index < 0 ) {           // normalize and retry  
  55. nw_member = qt_rmWS(member);     // remove whitespace  
  56. member = nw_member;  
  57. member_index = rmeta->findSignal( member, TRUE );  
  58.                          }  
  59.                          break;  
  60.            }  
  61.            /如果接收对象不存在相应的信号或槽,则退出  
  62.            if ( member_index < 0  ) {  
  63.                      return FALSE;  
  64.            }  
  65. //检查连接的参数(发送的信号,接收对象,处理信号的槽或信号)  
  66. if ( !s->checkConnectArgs(signal,receiver,member) ) {  
  67.                      return FALSE;  
  68.            } else {  
  69.                 //获取处理信号的元数据对象  
  70. const QMetaData *rm = membcode == QSLOT_CODE ?  
  71. rmeta->slot( member_index, TRUE ) :  
  72. rmeta->signal( member_index, TRUE );  
  73.                      if ( rm ) {            
  74.                          //建立连接  
  75.                             //(发送信号的对象,信号的索引,接收信号的对象,  
  76.                               处理信号的类型,处理信号的索引)  
  77.                         connectInternal( sender, signal_index, receiver, membcode, member_index );  
  78.                    }  
  79.               }  
  80.            return TRUE;  
  81.        }  
  82.  ②阶段  
  83.        //建立连接  
  84.        //(发送信号的对象,信号的索引,接收信号的对象,处理信号的类型,处理信号的索引)  
  85. void QObject::connectInternal( const QObject *sender, int signal_index,   
  86. const QObject *receiver, int membcode, int member_index )  
  87.       {  
  88.        //发送信号的对象  
  89.     QObject *s = (QObject*)sender;  
  90.        //接收信号的对象  
  91.     QObject *r = (QObject*)receiver;  
  92.     //如果发送对象的连接查询表为null,则建立  
  93.     if ( !s->connections ) {                // create connections lookup table  
  94.        s->connections = new QSignalVec( signal_index+1 );  
  95.        Q_CHECK_PTR( s->connections );  
  96.       s->connections->setAutoDelete( TRUE );  
  97.     }  
  98.     //获取发送对象的相应信号的连接列表  
  99.  
  100.     QConnectionList *clist = s->connections->at( signal_index );  
  101.  
  102.     if ( !clist ) {                         // create receiver list  
  103.        clist = new QConnectionList;  
  104.        Q_CHECK_PTR( clist );  
  105.        clist->setAutoDelete( TRUE );  
  106.        s->connections->insert( signal_index, clist );  
  107.     }  
  108.     QMetaObject *rrmeta = r->metaObject();  
  109.    const QMetaData *rm = 0;  
  110.     switch ( membcode ) {                // get receiver member  
  111.        case QSLOT_CODE:  
  112.            rm = rmeta->slot( member_index, TRUE );  
  113.            break;  
  114.        case QSIGNAL_CODE:  
  115.            rm = rmeta->signal( member_index, TRUE );  
  116.            break;  
  117.     }  
  118.     //建立连接  
  119. QConnection *c = new QConnection( r, member_index, rm ? rm->name :   
  120.                                                                       "qt_invoke", membcode );  
  121.     Q_CHECK_PTR( c );  
  122.    //把连接添加到发送对象的连接列表中  
  123.     clist->append( c );  
  124.     //判断接收对象的发送对象列表是否为null  
  125.     if ( !r->senderObjects )               // create list of senders  
  126.            {  
  127.           //建立接收对象的发送对象列表  
  128.        r->senderObjects = new QSenderObjectList;  
  129.           }  
  130.     //把发送对象添加到发送对象列表中  
  131.     r->senderObjects->append( s );           // add sender to list  
  132.        } 

(2)信号发生时激活的操作函数。 激活slot的方法

  1. 接口:

  2.  void QObject::activate_signal( int signal )  
  3.        {  
  4.        #ifndef QT_NO_PRELIMINARY_SIGNAL_SPY  
  5.            if ( qt_preliminary_signal_spy ) {  
  6.                   //信号没有被阻塞  
  7.                   //信号>=0  
  8.                   //连接列表不为空,或者信号对应的连接存在  
  9.               if ( !signalsBlocked() && signal >= 0 &&  
  10.                 ( !connections || !connections->at( signal ) ) ) {  
  11.                  //  
  12.                  QUObject o[1];  
  13.                   qt_spy_signal( this, signal, o );  
  14.                   return;  
  15.               }  
  16.     }  
  17.        #endif  
  18.     if ( !connections || signalsBlocked() || signal < 0 )  
  19.        return;  
  20.     //获取信号对应的连接列表  
  21.     QConnectionList *clist = connections->at( signal );  
  22.     if ( !clist )  
  23.        return;  
  24.    QUObject o[1];  
  25.     //  
  26.     activate_signal( clist, o );  
  27. }  
  28.  
  29. void QObject::activate_signal( QConnectionList *clist, QUObject *o )  
  30. {  
  31.     if ( !clist )  
  32.        return;  
  33. #ifndef QT_NO_PRELIMINARY_SIGNAL_SPY  
  34.     if ( qt_preliminary_signal_spy )  
  35.        qt_spy_signal( this, connections->findRef( clist), o );  
  36. #endif  
  37.     QObject *object;  
  38.        //发送对象列表  
  39.     QSenderObjectList* sol;  
  40.        //旧的发送对象  
  41.     QObject* oldSender = 0;  
  42.        //连接  
  43.     QConnection *c;  
  44.     if ( clist->count() == 1 ) { // save iterator  
  45.            //获取连接  
  46.        c = clist->first();  
  47.        //  
  48.        object = c->object();  
  49.        //获取发送对象列表  
  50.        sol = object->senderObjects;  
  51.        if ( sol ) {  
  52.               //获取旧的发送对象  
  53.           oldSender = sol->currentSender;  
  54.               //  
  55.            sol->ref();  
  56.               //设置新的发送对象  
  57.            sol->currentSender = this;  
  58.        }  
  59.        if ( c->memberType() == QSIGNAL_CODE )//如果是信号,则发送出去  
  60.            object->qt_emit( c->member(), o );  
  61.        else  
  62.            object->qt_invoke( c->member(), o );//如果是槽,则执行  
  63.        //       
  64.        if ( sol ) {  
  65.               //设置恢复为旧的发送对象  
  66.            sol->currentSender = oldSender;  
  67.            if ( sol->deref() )  
  68.               delete sol;  
  69.        }  
  70.     } else {  
  71.        QConnection *cd = 0;  
  72.        QConnectionListIt it(*clist);  
  73.        while ( (c=it.current()) ) {  
  74.           ++it;  
  75.           if ( c == cd )  
  76.              continue;  
  77.            ccd = c;  
  78.            object = c->object();  
  79.            //操作前设置当前发送对象  
  80.            sol = object->senderObjects;  
  81.            if ( sol ) {  
  82.               oldSender = sol->currentSender;  
  83.               sol->ref();  
  84.               sol->currentSender = this;  
  85.           }  
  86.            //如果是信号,则发送出去  
  87.            if ( c->memberType() == QSIGNAL_CODE ){  
  88.               object->qt_emit( c->member(), o );  
  89.            }  
  90.            //如果是槽,则执行  
  91.            else{  
  92.               object->qt_invoke( c->member(), o );  
  93.            }  
  94.            //操作后恢复当前发送对象  
  95.            if (sol ) {  
  96.               sol->currentSender = oldSender;  
  97.               if ( sol->deref() )  
  98.                   delete sol;  
  99.            }  
  100.        }  
  101.     }  

【编辑推荐】

Qt的插件机制

QT的信号与槽机制

Qt网络之获取本机网络信息

浅谈自动化测试工具 QTP脚本的重用

Qt和KDE在未来将面临新的挑战和机遇

责任编辑:zhaolei 来源: 互联网
相关推荐

2011-06-09 09:45:35

Linux QT 信号

2011-06-23 14:40:13

Qt 信号

2011-06-15 14:38:01

QT 信号

2021-12-23 15:07:40

QtC++编译程序

2011-06-23 13:38:27

QT 元对象 信号

2011-06-28 15:47:13

Qt 信号

2023-10-07 08:21:35

PyQtPython

2011-06-20 15:40:19

QT 信号

2011-07-05 18:32:52

QT 信号 机制

2011-07-05 18:40:19

QT 信号 机制

2011-06-22 17:09:50

QT 进程 通信

2011-06-23 14:05:32

Qt 事件机制

2021-05-14 16:34:12

Semaphore原理

2011-08-23 14:33:51

Lua捕获字符串

2010-07-30 14:22:47

RIP协议

2020-07-19 10:26:47

Kubernetes数据结构

2011-07-01 14:34:02

Thread Affinity 信号

2021-08-01 08:05:39

Linux信号原理

2011-06-30 17:31:32

Qt 多线程 信号

2009-09-04 10:37:50

Java堆栈溢出
点赞
收藏

51CTO技术栈公众号