2. 程式人生 > >深入探究connect函式

深入探究connect函式

阿新 • • 發佈：2019-01-28


connect，是QT中的連線函式，將訊號傳送者sender物件中的訊號signal與接受者receiver中的member槽函式聯絡起來。 

QObject::connect的定義是這樣的：

    static bool connect(const QObject *sender, const char *signal,
                        const QObject *receiver, const char *member, Qt::ConnectionType =
        #ifdef qdoc
                         Qt::AutoConnection
        #else
         #ifdef QT3_SUPPORT
                          Qt::AutoCompatConnection
        #else
                              Qt::AutoConnection
         #endif
        #endif
        );
    inline bool connect(const QObject *sender, const char *signal,
                        const char *member, Qt::ConnectionType type =
        #ifdef qdoc
                         Qt::AutoConnection
        #else
         #ifdef QT3_SUPPORT
                              Qt::AutoCompatConnection
         #else
                              Qt::AutoConnection
         #endif
        #endif
        ) const;

其中第二個connect的實現其實只有一句話：

{ return connect(asender, asignal, this, amember, atype); }  

所以對於connect函式的學習其實就是研究第一個connect函式。

在使用connect函式的時候一般是這樣呼叫的：

connect(sender,SIGNAL(signal()),receiver,SLOT(slot()));  

兩個巨集：SIGNAL() 和SLOT()；通過connect宣告可以知道這兩個巨集最後倒是得到一個const char*型別。
在qobjectdefs.h中可以看到SIGNAL() 和SLOT()的巨集定義：

  1. #ifndef QT_NO_DEBUG  
  2. # define QLOCATION "\0"__FILE__":"QTOSTRING(__LINE__)  
  3. # define METHOD(a)   qFlagLocation("0"#a QLOCATION)  
  4. # define SLOT(a)     qFlagLocation("1"#a QLOCATION)  
  5. # define SIGNAL(a)   qFlagLocation("2"#a QLOCATION)  
  6. #else  
  7. # define METHOD(a)   "0"#a  
  8. # define SLOT(a)     "1"#a  
  9. # define SIGNAL(a)   "2"#a
      
  10. #endif  

這兩個巨集的作用就是把函式名轉換為字串並且在前面加上識別符號。

比如：SIGNAL(read())展開後就是"2read()"；同理SLOT(read())展開後就是"1read()"。

connect(sender,SIGNAL(signal()),receiver,SLOT(slot()));  

實際上就是connect(sender,“2signal()”,receiver,“1slot())”;  

在QObject.cpp檔案中可以找到connect的實現程式碼，下面是去除了debug程式碼的connect實現。

  1. bool QObject::connect(const QObject *sender, constchar *signal,  
  2.                       const QObject *receiver, constchar *method,  
  3.                       Qt::ConnectionType type)  
  4. {  
  5.     {  
  6.         constvoid *cbdata[] = { sender, signal, receiver, method, &type };  
  7.         if (QInternal::activateCallbacks(QInternal::ConnectCallback, (void **) cbdata))  
  8.             returntrue;  
  9.     }  
  10.     if (sender == 0 || receiver == 0 || signal == 0 || method == 0) {  
  11.         qWarning("QObject::connect: Cannot connect %s::%s to %s::%s",  
  12.                  sender ? sender->metaObject()->className() : "(null)",  
  13.                  (signal && *signal) ? signal+1 : "(null)",  
  14.                  receiver ? receiver->metaObject()->className() : "(null)",  
  15.                  (method && *method) ? method+1 : "(null)");  
  16.         returnfalse;  
  17.     }  
  18.     QByteArray tmp_signal_name;  
  19.     if (!check_signal_macro(sender, signal, "connect", "bind"))  
  20.         returnfalse;  
  21.     const QMetaObject *smeta = sender->metaObject();  
  22.     constchar *signal_arg = signal;  
  23.     ++signal; //skip code
  24.     int signal_index = smeta->indexOfSignal(signal);  
  25.     if (signal_index < 0) {  
  26.         // check for normalized signatures
  27.         tmp_signal_name = QMetaObject::normalizedSignature(signal - 1);  
  28.         signal = tmp_signal_name.constData() + 1;  
  29.         signal_index = smeta->indexOfSignal(signal);  
  30.         if (signal_index < 0) {  
  31.             err_method_notfound(sender, signal_arg, "connect");  
  32.             err_info_about_objects("connect", sender, receiver);  
  33.             returnfalse;  
  34.         }  
  35.     }  
  36.     QByteArray tmp_method_name;  
  37.     int membcode = extract_code(method);  
  38.     if (!check_method_code(membcode, receiver, method, "connect"))  
  39.         returnfalse;  
  40.     constchar *method_arg = method;  
  41.     ++method; // skip code
  42.     const QMetaObject *rmeta = receiver->metaObject();  
  43.     int method_index = -1;  
  44.     switch (membcode) {  
  45.     case QSLOT_CODE:  
  46.         method_index = rmeta->indexOfSlot(method);  
  47.         break;  
  48.     case QSIGNAL_CODE:  
  49.         method_index = rmeta->indexOfSignal(method);  
  50.         break;  
  51.     }  
  52.     if (method_index < 0) {  
  53.         // check for normalized methods
  54.         tmp_method_name = QMetaObject::normalizedSignature(method);  
  55.         method = tmp_method_name.constData();  
  56.         switch (membcode) {  
  57.         case QSLOT_CODE:  
  58.             method_index = rmeta->indexOfSlot(method);  
  59.             break;  
  60.         case QSIGNAL_CODE:  
  61.             method_index = rmeta->indexOfSignal(method);  
  62.             break;  
  63.         }  
  64.     }  
  65.     if (method_index < 0) {  
  66.         err_method_notfound(receiver, method_arg, "connect");  
  67.         err_info_about_objects("connect", sender, receiver);  
  68.         returnfalse;  
  69.     }  
  70.     if (!QMetaObject::checkConnectArgs(signal, method)) {  
  71.         qWarning("QObject::connect: Incompatible sender/receiver arguments"
  72.                  "\n        %s::%s --> %s::%s",  
  73.                  sender->metaObject()->className(), signal,  
  74.                  receiver->metaObject()->className(), method);  
  75.         returnfalse;  
  76.     }  
  77.     int *types = 0;  
  78.     if ((type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)  
  79.             && !(types = queuedConnectionTypes(smeta->method(signal_index).parameterTypes())))  
  80.         returnfalse;  
  81.     QMetaObject::connect(sender, signal_index, receiver, method_index, type, types);  
  82.     const_cast<QObject*>(sender)->connectNotify(signal - 1);  
  83.     returntrue;  
  84. }  

判斷連線是否已經建立：

  1. constvoid *cbdata[] = { sender, signal, receiver, method, &type };  
  2. if (QInternal::activateCallbacks(QInternal::ConnectCallback, (void **) cbdata))  
  3.       returntrue; 

QInternal：：ConnectCallback在qglobal.cpp中實現：

  1. bool QInternal::activateCallbacks(Callback cb, void **parameters)  
  2. {  
  3.     Q_ASSERT_X(cb >= 0, "QInternal::activateCallback()", "Callback id must be a valid id");  
  4.     QInternal_CallBackTable *cbt = global_callback_table();  
  5.     if (cbt && cb < cbt->callbacks.size()) {  
  6.         QList<qInternalCallback> callbacks = cbt->callbacks[cb];  
  7.         bool ret = false;  
  8.         for (int i=0; i<callbacks.size(); ++i)  
  9.             ret |= (callbacks.at(i))(parameters);  
  10.         return ret;  
  11.     }  
  12.     returnfalse;  
  13. }  

QInternal_CallBackTable 定義為(qglobal.cpp)：

  1. struct QInternal_CallBackTable {  
  2.     QVector<QList<qInternalCallback> > callbacks;  
  3. };  

qInternalCallback定義為(qnamespace.h)：

  1. typedefbool (*qInternalCallback)(void **);

//這是一個函式指標 返回值是bool，只有一個引數為void**。這個指標在呼叫registerCallback加入列表。  

typedef bool (*qInternalCallback)(void **);這是一個函式指標 返回值是bool，只有一個引數為void**。這個指標在呼叫registerCallback加入列表。


 判斷signal是否合法

  1. if (!check_signal_macro(sender, signal, "connect", "bind"))  
  2.     returnfalse; 

在QObject.cpp檔案中可以找到check_signal_macro的實現

  1. staticbool check_signal_macro(const QObject *sender, constchar *signal,  
  2.                                 constchar *func, constchar *op)  
  3. {  
  4.     int sigcode = extract_code(signal);  
  5.     if (sigcode != QSIGNAL_CODE) {  
  6.         if (sigcode == QSLOT_CODE)  
  7.             qWarning("Object::%s: Attempt to %s non-signal %s::%s",  
  8.                      func, op, sender->metaObject()->className(), signal+1);  
  9.         else
  10.             qWarning("Object::%s: Use the SIGNAL macro to %s %s::%s",  
  11.                      func, op, sender->metaObject()->className(), signal);  
  12.         returnfalse;  
  13.     }  
  14.     returntrue;  
  15. }  

extract的實現也在QObject中，它就是去字串第一個字元，並且只取低2位的值。

  1. staticint extract_code(constchar *member)  
  2. {  
  3.     // extract code, ensure QMETHOD_CODE <= code <= QSIGNAL_CODE
  4.     return (((int)(*member) - '0') & 0x3);  
  5. }  

這裡有兩個巨集：QSIGNAL_CODE 和QSLOT_CODE。它們也是在qobjectdefs.h檔案中定義的。這個定義與之前的SIGNAL和SLOT的定義是對應的。

  1. #ifdef QT3_SUPPORT
  2. #define METHOD_CODE   0                        // member type codes
  3. #define SLOT_CODE     1
  4. #define SIGNAL_CODE   2
  5. #endif

獲取signal的索引，其中metaObject()是在moc_name.cpp檔案中生成的。

  1. const QMetaObject *smeta = sender->metaObject();  
  2. constchar *signal_arg = signal;  
  3. ++signal; //skip code
  4. int signal_index = smeta->indexOfSignal(signal);  
  5. if (signal_index < 0) {  
  6.     // check for normalized signatures
  7.     tmp_signal_name = QMetaObject::normalizedSignature(signal - 1);  
  8.     signal = tmp_signal_name.constData() + 1;  
  9.     signal_index = smeta->indexOfSignal(signal);  
  10.     if (signal_index < 0) {  
  11.         err_method_notfound(sender, signal_arg, "connect");  
  12.         err_info_about_objects("connect", sender, receiver);  
  13.         returnfalse;  
  14.     }  
  15. }  

return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;  

return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;

其中staticMetaObject也是在moc檔案中定義的

  1. const QMetaObject MainWindow::staticMetaObject = {  
  2.     { &QMainWindow::staticMetaObject, qt_meta_stringdata_MainWindow,  
  3.       qt_meta_data_MainWindow, 0 }  
  4. };  
  6. const QMetaObject MainWindow::staticMetaObject = {
    { &QMainWindow::staticMetaObject, qt_meta_stringdata_MainWindow,
      qt_meta_data_MainWindow, 0 }
};

qt_meta_stringdata_MainWindow（具體名字和類名有關）就是staticconstchar[]型別。它記錄了全部的signals和slots等的函式名、返回值和引數表的資訊。

qt_meta_data_MainWindow（具體名字和類名有關）是staticconstuint[]型別。它記錄了每一個函式的函式名、返回值和引數表在qt_meta_stringdata_MainWindow中的索引。同時它還記錄了每一個函式的型別具體在qmetaobject.cpp檔案中定義。

  1. enum MethodFlags  {  
  2.     AccessPrivate = 0x00,  
  3.     AccessProtected = 0x01,  
  4.     AccessPublic = 0x02,  
  5.     AccessMask = 0x03, //mask
  6.     MethodMethod = 0x00,  
  7.     MethodSignal = 0x04,  
  8.     MethodSlot = 0x08,  
  9.     MethodConstructor = 0x0c,  
  10.     MethodTypeMask = 0x0c,  
  11.     MethodCompatibility = 0x10,  
  12.     MethodCloned = 0x20,  
  13.     MethodScriptable = 0x40  
  14. };  
enum MethodFlags  {
    AccessPrivate = 0x00,
    AccessProtected = 0x01,
    AccessPublic = 0x02,
    AccessMask = 0x03, //mask

    MethodMethod = 0x00,
    MethodSignal = 0x04,
    MethodSlot = 0x08,
    MethodConstructor = 0x0c,
    MethodTypeMask = 0x0c,

    MethodCompatibility = 0x10,
    MethodCloned = 0x20,
    MethodScriptable = 0x40
};


indexOfSignal(signal);的實現在qmetaobject.cpp中。其主要作用是利用qt_meta_stringdata_MainWindow 和qt_meta_data_MainWindow查詢已經定義了的signal並返回索引。
 

  1. QByteArray tmp_method_name;  
  2. int membcode = extract_code(method);  
  3. if (!check_method_code(membcode, receiver, method, "connect"))  
  4.     returnfalse;  
  5. constchar *method_arg = method;  
  6. ++method; // skip code
  7. const QMetaObject *rmeta = receiver->metaObject();  
  8. int method_index = -1;  
  9. switch (membcode) {  
  10. case QSLOT_CODE:  
  11.     method_index = rmeta->indexOfSlot(method);  
  12.     break;  
  13. case QSIGNAL_CODE:  
  14.     method_index = rmeta->indexOfSignal(method);  
  15.     break;  
  16. }  
  17. if (method_index < 0) {  
  18.     // check for normalized methods
  19.     tmp_method_name = QMetaObject::normalizedSignature(method);  
  20.     method = tmp_method_name.constData();  
  21.     switch (membcode) {  
  22.     case QSLOT_CODE:  
  23.         method_index = rmeta->indexOfSlot(method);  
  24.         break;  
  25.     case QSIGNAL_CODE:  
  26.         method_index = rmeta->indexOfSignal(method);  
  27.         break;  
  28.     }  
  29. }  
  30. if (method_index < 0) {  
  31.     err_method_notfound(receiver, method_arg, "connect");  
  32.     err_info_about_objects("connect", sender, receiver);  
  33.     returnfalse;  
  34. }  
    QByteArray tmp_method_name;
    int membcode = extract_code(method);

    if (!check_method_code(membcode, receiver, method, "connect"))
        return false;
    const char *method_arg = method;
    ++method; // skip code

    const QMetaObject *rmeta = receiver->metaObject();
    int method_index = -1;
    switch (membcode) {
    case QSLOT_CODE:
        method_index = rmeta->indexOfSlot(method);
        break;
    case QSIGNAL_CODE:
        method_index = rmeta->indexOfSignal(method);
        break;
    }
    if (method_index < 0) {
        // check for normalized methods
        tmp_method_name = QMetaObject::normalizedSignature(method);
        method = tmp_method_name.constData();
        switch (membcode) {
        case QSLOT_CODE:
            method_index = rmeta->indexOfSlot(method);
            break;
        case QSIGNAL_CODE:
            method_index = rmeta->indexOfSignal(method);
            break;
        }
    }

    if (method_index < 0) {
        err_method_notfound(receiver, method_arg, "connect");
        err_info_about_objects("connect", sender, receiver);
        return false;
    }


校驗method並且查詢它的索引。過程與signal類似。

  1. if (!QMetaObject::checkConnectArgs(signal, method)) {  
  2.     qWarning("QObject::connect: Incompatible sender/receiver arguments"
  3.              "\n        %s::%s --> %s::%s",  
  4.              sender->metaObject()->className(), signal,  
  5.              receiver->metaObject()->className(), method);  
  6.     returnfalse;  
  7. }  
    if (!QMetaObject::checkConnectArgs(signal, method)) {
        qWarning("QObject::connect: Incompatible sender/receiver arguments"
                 "\n        %s::%s --> %s::%s",
                 sender->metaObject()->className(), signal,
                 receiver->metaObject()->className(), method);
        return false;
    }


判斷signal和method是否相容，checkConnectArgs函式的在qmetaObject.cpp檔案中實現。這個函式校驗了signal和method的引數。當兩者的引數一致或method引數比signal引數少（method與signal前幾個引數一致）的時候返回true，其它返回false。

  1. int *types = 0;  
  2. if ((type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)  
  3.         && !(types = queuedConnectionTypes(smeta->method(signal_index).parameterTypes())))  
  4.     returnfalse;  
    int *types = 0;
    if ((type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
            && !(types = queuedConnectionTypes(smeta->method(signal_index).parameterTypes())))
        return false;


如果是以發訊息的方式執行method就需要對引數型別進行判斷。queuedConnectionTypes在QObject.cpp實現。實際上是在QMetatype.cpp中定義了一個

staticconststruct{constchar*typeName;inttype;}types[]；在這裡記錄了全部型別和名稱如（{"void",QMetaType::Void}）；Void在Qmetatype.h中定義。

  1. QMetaObject::connect(sender, signal_index, receiver, method_index, type, types);  
QMetaObject::connect(sender, signal_index, receiver, method_index, type, types);


呼叫QMetaObject的connect函式，不詳細寫出。

  1. const_cast<QObject*>(sender)->connectNotify(signal - 1);  
const_cast<QObject*>(sender)->connectNotify(signal - 1);


最後呼叫虛擬函式connectNotify表示connect已經執行完成。

  2.  const void *cbdata[] = { sender, signal, receiver, method, &type };
 if (QInternal::activateCallbacks(QInternal::ConnectCallback, (void **) cbdata))
       return true;

相關推薦

深入探究connect函式

 connect，是QT中的連線函式，將訊號傳送者sender物件中的訊號signal與接受者receiver中的member槽函式聯絡起來。  QObject::connect的定義是這樣的：     static bool connect(const QObject

java深入探究06

定義 auth ttr null hist context 編號 http 使用 Tomcat中獲取資源文件： ServletContext().getRealPath(/WEB-INF/classes/db.properties);//獲取資源文件的在服務器中的絕對路徑

java深入探究11-基礎加強

filesize backup cati write 問題 參數化 tor 嵌套 gif 1. ? extends String:String 子類;? super String:String 父類 2.反射-》參數化類型表示 　　ParameteredType:參數化類型

Nodejs cluster模塊深入探究

js由表及裏HTTP服務器用於響應來自客戶端的請求當客戶端請求數逐漸增大時服務端的處理機制有多種如tomcat的多線程、nginx的事件循環等。而對於node而言由於其也采用事件循環和異步I/O機制因此在高I/O並發的場景下性能非常好但是由於單個node程序僅僅利用單核cpu因此為了更好利用系統資源就需要fo

java finally深入探究

關閉 jdk1 turn 轉移 color get 能夠 www. 分析 When---什麽時候需要finally： 在jdk1.7之前，所有涉及到I/O的相關操作，我們都會用到finally，以保證流在最後的正常關閉。jdk1.7之後，雖然所有實現Closable接口的流

對this關鍵字的深入探究

樣式 src 因此 完全 記錄 優先 spa img col 　　this無疑是javascript中特別復雜的機制了，最使我們困擾的就是this的指向，僅以本文對我所理解的this做一個總結和記錄。每一句話都是重點！文章參考《你不知道的javascript》。 　　首先需

Android圖片載入框架最全解析（三），深入探究Glide的快取機制(筆記)

原文地址：Android圖片載入框架最全解析（三），深入探究Glide的快取機制 筆記： 1.Glide快取簡介 2.快取Key EngineKey 重寫了equals()和hashCode()方法，保證只有傳入EngineKey的所有引數都相同的情況下才認為是

connect函式詳解

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

tcp connect函式的解釋

    如果是tcp套接字，呼叫connect函式將激發tcp的三路握手過程，而且僅在 連線成功或出錯時返回，其中出錯返回可能有以下幾種情況。     1、若tcp客戶沒有收到SYN分節的響應，則返回ETIMEDOUT錯誤，舉例來說，呼叫

c++ 入門之深入探討拷貝函式和賦值運算子

在c++入門之深入探討類的一些行為時，說明了拷貝函式即複製建構函式運用於如下場景： 物件作為函式的引數，以值傳遞的方式傳給函式。　 物件作為函式的返回值，以值的方式從函式返回 使用一個物件給另一個物件初始化 針對上述的三種情況，實際上很多時候，我們都會用到；如果我們採用系統預設的拷貝函式

iOS 深入探究 AutoreleasePool

AutoreleasePool 是什麼 AutoreleasePool （下面稱為快取池）是 iOS 開發中的一種記憶體管理的機制，物件呼叫 autorelease 方法後會被放到快取池中延遲釋放，當快取池需要清除時，會向這些 Autoreleased 物件傳送 release 訊息。 新建一個 Xcod

（三）提升樹模型：Lightgbm原理深入探究

本篇部落格是提升樹模型部落格的第三篇文章，也是最後一篇文章。 第一篇介紹GBDT的部落格可以參看這裡。 第二篇介紹Xgboost的部落格可以參看這裡。 本篇部落格主要講解輕量級的提升樹模型-LightGBM。 LightGBM的資料網上也出現很多，但是講解的都很淺，大部分都是從官方文

深入探究docker attach的退出方式

標準 部分 enc correct nds ace mage 退出 容器 docker attach可以將當前終端的標準輸入、標準輸出和標準錯誤連接到指定的容器中，可以顯示容器 ENTRYPOINT/CMD 進程的輸出，是容器調試的重要方法。docker attach之後退

深入javascript——建構函式和原型物件

  常用的幾種物件建立模式 使用new關鍵字建立 最基礎的物件建立方式，無非就是和其他多數語言一樣說的一樣：沒物件，你new一個呀！ var gf = new Object(); gf.name = "ta

QT訊號槽connect函式詳解

使用QT開發時，通常使用connect函式只傳遞四個引數： connect(Sender,SIGNAL(signal),Receiver,SLOT(slot)); 所以我們有可能認為該函式就只有四個引數，但實際上是有第五個引數的，只是通常該函式已經給第五個引數賦值了而已，我們所使用的是預設值

深入探究immutable.js的實現機制（一）

Immutable.js 採用了持久化資料結構和結構共享，保證每一個物件都是不可變的，任何新增、修改、刪除等操作都會生成一個新的物件，且通過結構共享等方式大幅提高效能。網上已經有很多文章簡單介紹了 Immutable.js 的原理，但基本都是淺嘗輒止，我也是搜了很久

18-UDP的connect函式

1. 面向連線的UDP   在上一篇中遺留了一個問題：sendto函式產生的非同步錯誤一般是不會返回給udp套接字的（主要是因為udp是無連線的原因），如果這個錯誤要返回給udp套接字，那麼就需要呼叫connect函式。 是的，你沒看錯，udp也可以呼叫connect函式達

網路程式設計socket之connect函式

網路程式設計socket api存在一批核心介面，而這一批核心介面就是幾個看似簡單的函式，儘管實際上這些函式沒有一個是簡單。connect函式就是這些核心介面的一個函式，它完成主動連線的過程。    connect函式的功能是完成一個有連線協議的連線過程，對於TCP來說就是那個

17.UDP與connect()函式；ICMP非同步錯誤

1.connect在UDP中的用途 [**ICMP非同步錯誤] ICMP非同步錯誤是指：傳送報文的時候，沒有錯誤；接收報文的時候，會收到ICMP應答 重點：非同步錯誤，無法返回給未連線的套接字。UDP可

《Java之JVM》---深入探究之GC垃圾回收演算法

預計要閱讀十多分鐘! 首先,談一下什麼是GC(Garbage Collection)。說起GC，大部分人都把這項技術當做Java語言的伴生產物。事實上，GC的歷史比Java久遠，早在1960年Lisp這門語言中就使用了記憶體動態分配和垃圾回收技術。在Java中