कैसे संकेत और स्लॉट Qt में काम करते हैं (भाग 1)

Qt अपने सिग्नल और स्लॉट तंत्र के लिए अच्छी तरह से जाना जाता है। लेकिन यह कैसे काम करता है? इस पोस्ट में, हम QObject और QMetaObject के इनसाइड का पता लगाते हैं और पर्दे के पीछे से उनके काम का खुलासा करते हैं। मैं Qt5 कोड का उदाहरण दूंगा, कभी-कभी संक्षिप्तता और स्वरूपण के लिए संपादित किया जाता है।

सिग्नल और स्लॉट

शुरुआत करने के लिए, आइए याद रखें कि आधिकारिक उदाहरण को देखते हुए सिग्नल और स्लॉट क्या दिखते हैं। शीर्ष लेख फ़ाइल इस प्रकार है:

class Counter : public QObject { Q_OBJECT int m_value; public: int value() const { return m_value; } public slots: void setValue(int value); signals: void valueChanged(int newValue); }; 

कहीं न कहीं, एक .cpp फ़ाइल में, हम setValue () लागू करते हैं :

 void Counter::setValue(int value) { if (value != m_value) { m_value = value; emit valueChanged(value); } } 

फिर, हम इस तरह से काउंटर ऑब्जेक्ट का उपयोग कर सकते हैं:

 Counter a, b; QObject::connect(&a, SIGNAL(valueChanged(int)), &b, SLOT(setValue(int))); a.setValue(12); // a.value() == 12, b.value() == 12 

यह मूल सिंटैक्स है जो 1992 में क्यूटी शुरू होने के बाद से मुश्किल से बदल गया है। लेकिन भले ही कोर एपीआई नहीं बदला गया हो, कार्यान्वयन कई बार बदल गया है। हुड के तहत, नई सुविधाओं को जोड़ा गया और अन्य चीजें हुईं। यहां कोई जादू नहीं है और मैं दिखाऊंगा कि यह कैसे काम करता है।

MOC या मेटा ऑब्जेक्ट कंपाइलर

सिग्नल और स्लॉट, साथ ही गुणों की क्यूटी प्रणाली, कार्यक्रम के निष्पादन के दौरान वस्तुओं के आत्म-विश्लेषण की संभावनाओं पर आधारित है। आत्मनिरीक्षण का अर्थ है किसी वस्तु के तरीकों और गुणों को सूचीबद्ध करने की क्षमता और उनके बारे में सभी जानकारी, विशेष रूप से, उनके तर्कों के प्रकारों के बारे में। QtScript और QML इसके बिना शायद ही संभव होता।

सी ++ देशी आत्मनिरीक्षण सहायता प्रदान नहीं करता है, इसलिए क्यूटी एक उपकरण के साथ आता है जो इसे प्रदान करता है। इस टूल को MOC कहा जाता है। यह एक कोड जनरेटर है (लेकिन एक प्रीप्रोसेसर नहीं है, जैसा कि कुछ लोग सोचते हैं)।

यह हेडर फ़ाइलों को पार्स करता है और एक अतिरिक्त C ++ फ़ाइल उत्पन्न करता है जो बाकी प्रोग्राम के साथ संकलित करता है। यह उत्पन्न C ++ फ़ाइल में आत्मनिरीक्षण के लिए आवश्यक सभी जानकारी है।
क्यूटी को कभी-कभी भाषा शुद्धतावादियों द्वारा आलोचना की जाती है, क्योंकि यह एक अतिरिक्त कोड जनरेटर है। मैं क्यूटी प्रलेखन को इस आलोचना का जवाब देने की अनुमति दूंगा । कोड जनरेटर के साथ कुछ भी गलत नहीं है और MOC एक उत्कृष्ट सहायक है।

मैजिक मैक्रों

क्या आप ऐसे कीवर्ड देख सकते हैं जो C ++ कीवर्ड नहीं हैं? संकेत , स्लॉट्स , Q_OBJECT , emit , SIGNAL , SLOT । उन्हें C ++ के लिए Qt एक्सटेंशन के रूप में जाना जाता है। ये वास्तव में सरल मैक्रोज़ हैं जो क़ोबिज़डेफ़िश में परिभाषित किए गए हैं।

 #define signals public #define slots /* nothing */ 

सच है, सिग्नल और स्लॉट सरल कार्य हैं: संकलक उन्हें किसी अन्य फ़ंक्शन की तरह संसाधित करता है। मैक्रोज़ अभी भी एक विशिष्ट उद्देश्य की सेवा करते हैं: एमओसी उन्हें देखता है। संकेत Qt4 और पहले के संरक्षित खंड में थे। लेकिन Qt5 में वे पहले से ही नए सिंटैक्स का समर्थन करने के लिए खुले हैं।

 #define Q_OBJECT \ public: \ static const QMetaObject staticMetaObject; \ virtual const QMetaObject *metaObject() const; \ virtual void *qt_metacast(const char *); \ virtual int qt_metacall(QMetaObject::Call, int, void **); \ QT_TR_FUNCTIONS /*   */ \ private: \ Q_DECL_HIDDEN static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); 

Q_OBJECT फ़ंक्शंस का एक समूह और एक स्थिर QMetaObject को परिभाषित करता है। ये कार्य MOC द्वारा उत्पन्न फ़ाइल में कार्यान्वित किए जाते हैं।

 #define emit /* nothing */ 

एमिट एक खाली मैक्रो है। यह MOC को पार्स भी नहीं करता है। दूसरे शब्दों में, उत्सर्जन वैकल्पिक है और इसका कोई मतलब नहीं है (डेवलपर के लिए संकेत के अलावा)।

 Q_CORE_EXPORT const char *qFlagLocation(const char *method); #ifndef QT_NO_DEBUG # define QLOCATION "\0" __FILE__ ":" QTOSTRING(__LINE__) # define SLOT(a) qFlagLocation("1"#a QLOCATION) # define SIGNAL(a) qFlagLocation("2"#a QLOCATION) #else # define SLOT(a) "1"#a # define SIGNAL(a) "2"#a #endif 

इन मैक्रोज़ का उपयोग प्रीप्रोसेसर द्वारा पैरामीटर को स्ट्रिंग में बदलने और शुरुआत में कोड जोड़ने के लिए किया जाता है। डिबग मोड में, हम सिग्नल के साथ कनेक्शन काम नहीं करने पर एक चेतावनी के साथ फ़ाइल के स्थान के साथ लाइन को भी पूरक करते हैं। यह संगतता के लिए Qt 4.5 में जोड़ा गया था। यह जानने के लिए कि कौन सी पंक्तियों में पंक्ति के बारे में जानकारी है, हम qFlagLocation का उपयोग करते हैं , जो दो समावेशन के साथ तालिका में पंक्ति के पते को पंजीकृत करता है।

अब MOC द्वारा उत्पन्न कोड पर चलते हैं।

QMetaObject

 const QMetaObject Counter::staticMetaObject = { { &QObject::staticMetaObject, qt_meta_stringdata_Counter.data, qt_meta_data_Counter, qt_static_metacall, 0, 0 } }; const QMetaObject *Counter::metaObject() const { return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; } 

यहां हम काउंटर :: मेटाऑब्जेक्ट () और काउंटर :: staticMetaObject का कार्यान्वयन देखते हैं। उन्हें Q_OBJECT मैक्रो में घोषित किया गया है। QObject :: d_ptr-> metaObject का उपयोग केवल डायनामिक मेटा ऑब्जेक्ट्स ( QML ऑब्जेक्ट्स) के लिए किया जाता है, इसलिए, सामान्य स्थिति में, वर्चुअल फ़ंक्शन metaObject () बस एक staticMetaObject क्लास देता है। staticMetaObject रीड-ओनली डेटा के साथ बनाया गया है। QMetaObject को qobjectdefs.h में परिभाषित किया गया है:

 struct QMetaObject { /* ...     ... */ enum Call { InvokeMetaMethod, ReadProperty, WriteProperty, /*...*/ }; struct { //   const QMetaObject *superdata; const QByteArrayData *stringdata; const uint *data; typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **); StaticMetacallFunction static_metacall; const QMetaObject **relatedMetaObjects; void *extradata; //     } d; }; 

डी अप्रत्यक्ष रूप से इस बात का प्रतीक है कि सभी सदस्यों को छिपाया जाना चाहिए, लेकिन वे POD और स्थैतिक प्रारंभ की संभावना को संरक्षित करने के लिए छिपे नहीं हैं।

QMetaObject को पैरेंट क्लास सुपरडेटा की मेटा ऑब्जेक्ट (QObject :: staticMetaObject इस मामले में) का उपयोग करके आरंभीकृत किया गया है। स्ट्रैंडिंगटा और डेटा को कुछ डेटा के साथ आरंभीकृत किया जाता है, जिस पर बाद में चर्चा की जाएगी। static_metacall काउंटर द्वारा शुरू किए गए फ़ंक्शन का एक सूचक है :: qt_static_metacall।

आत्मनिरीक्षण सारणी

सबसे पहले, आइए QMetaObject के मूल डेटा पर एक नज़र डालें।

 static const uint qt_meta_data_Counter[] = { // content: 7, // revision 0, // classname 0, 0, // classinfo 2, 14, // methods 0, 0, // properties 0, 0, // enums/sets 0, 0, // constructors 0, // flags 1, // signalCount // signals: name, argc, parameters, tag, flags 1, 1, 24, 2, 0x05, // slots: name, argc, parameters, tag, flags 4, 1, 27, 2, 0x0a, // signals: parameters QMetaType::Void, QMetaType::Int, 3, // slots: parameters QMetaType::Void, QMetaType::Int, 5, 0 // eod }; 

पहले 13 इंच हेडर बनाते हैं। यह दो कॉलम प्रदान करता है, पहला कॉलम मात्रा है, और दूसरा उस सरणी का सूचकांक है जहां विवरण शुरू होता है। वर्तमान मामले में, हमारे पास दो विधियाँ हैं, और विधियों का वर्णन 14 के अनुक्रमणिका में शुरू होता है।
विधि का वर्णन 5 int के होते हैं। पहला नाम है, पंक्ति तालिका में सूचकांक (हम बाद में इसकी विस्तार से जांच करेंगे)। दूसरा पूर्णांक पैरामीटर की संख्या है, इसके बाद सूचकांक, जहां हम उनका वर्णन पा सकते हैं। अब हम टैग और झंडे को नजरअंदाज करेंगे। प्रत्येक फ़ंक्शन के लिए, MOC प्रत्येक पैरामीटर के रिटर्न प्रकार, उनके प्रकार और नाम सूचकांक को भी संग्रहीत करता है।

पंक्ति तालिका

 struct qt_meta_stringdata_Counter_t { QByteArrayData data[6]; char stringdata[47]; }; #define QT_MOC_LITERAL(idx, ofs, len) \ Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ offsetof(qt_meta_stringdata_Counter_t, stringdata) + ofs \ - idx * sizeof(QByteArrayData) \ ) static const qt_meta_stringdata_Counter_t qt_meta_stringdata_Counter = { { QT_MOC_LITERAL(0, 0, 7), QT_MOC_LITERAL(1, 8, 12), QT_MOC_LITERAL(2, 21, 0), QT_MOC_LITERAL(3, 22, 8), QT_MOC_LITERAL(4, 31, 8), QT_MOC_LITERAL(5, 40, 5) }, ""Counter\0valueChanged\0\0newValue\0setValue\0"" ""value\0"" }; #undef QT_MOC_LITERAL 

मूल रूप से, यह एक स्थिर QByteArray सरणी ( QT_MOC_LITERAL मैक्रो द्वारा बनाई गई) है, जो नीचे दी गई पंक्ति में एक विशिष्ट सूचकांक को संदर्भित करता है।

संकेत

MOC संकेतों को भी लागू करता है। वे कार्य हैं जो केवल तर्कों के लिए व्यूअर का एक सरणी बनाते हैं और उन्हें QMetaObject :: सक्रिय करने के लिए पास करते हैं । सरणी का पहला तत्व रिटर्न वैल्यू है। हमारे उदाहरण में, यह 0 है क्योंकि रिटर्न वैल्यू शून्य है। तीसरे तर्क को सक्रिय करने के लिए पारित संकेत सूचकांक (इस मामले में 0) है।

 // SIGNAL 0 void Counter::valueChanged(int _t1) { void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) }; QMetaObject::activate(this, &staticMetaObject, 0, _a); } 

स्लॉट कॉल

Qt_static_metacall फ़ंक्शन का उपयोग करके इसके अनुक्रमणिका द्वारा एक स्लॉट को कॉल करना भी संभव है:

 void Counter::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) { if (_c == QMetaObject::InvokeMetaMethod) { Counter *_t = static_cast<Counter *>(_o); switch (_id) { case 0: _t->valueChanged((*reinterpret_cast< int(*)>(_a[1]))); break; case 1: _t->setValue((*reinterpret_cast< int(*)>(_a[1]))); break; default: ; } ... } ... } 

संकेत में तर्क के लिए संकेत के रूप में एक ही प्रारूप में। _a [0] को छुआ नहीं जाता है, क्योंकि शून्य हर जगह लौटता है।

इंडेक्स के बारे में ध्यान दें

प्रत्येक QMetaObject के लिए , सिग्नल, स्लॉट, और किसी ऑब्जेक्ट के अन्य तथाकथित तरीके, इंडेक्स 0. से शुरू किए जाते हैं। उन्हें ऑर्डर दिया जाता है ताकि सिग्नल पहले आएं, फिर स्लॉट और फिर अन्य तरीके। अंदर के इन सूचकांकों को सापेक्ष सूचकांक कहा जाता है। उनमें माता-पिता के सूचकांक शामिल नहीं हैं। लेकिन सामान्य तौर पर, हम एक अधिक वैश्विक सूचकांक नहीं जानना चाहते हैं, जो किसी विशेष वर्ग से संबंधित नहीं है, लेकिन विरासत श्रृंखला में अन्य सभी तरीकों को शामिल करता है। इसलिए, हम बस सापेक्ष सूचकांक में एक ऑफसेट जोड़ते हैं और एक पूर्ण सूचकांक प्राप्त करते हैं। सार्वजनिक एपीआई में उपयोग किए जाने वाले इस सूचकांक को फॉर्म QMetaObject :: indexOf {सिग्नल, स्लॉट, विधि} के कार्यों द्वारा लौटाया जाता है।

जुड़ने का तंत्र संकेतों के लिए अनुक्रमित एक सरणी का उपयोग करता है। लेकिन सभी स्लॉट इस सरणी में एक स्थान पर कब्जा कर लेते हैं और आमतौर पर संकेतों की तुलना में अधिक स्लॉट होते हैं। तो, क्यूटी 4.6 के साथ, संकेतों के लिए एक नया आंतरिक सूचकांक प्रकट होता है, जिसमें केवल संकेतों के लिए उपयोग किए जाने वाले सूचकांक शामिल हैं। यदि आप क्यूटी के साथ विकसित कर रहे हैं, तो आपको केवल तरीकों के लिए पूर्ण सूचकांक के बारे में जानने की आवश्यकता है। लेकिन जब आप QObject के सोर्स कोड को देख रहे हों , तो आपको इन तीनों इंडेक्स के बीच का अंतर पता होना चाहिए।

कनेक्शन कैसे काम करता है

कनेक्ट करते समय पहली बात यह है कि सिग्नल और स्लॉट इंडेक्स को देखना है। Qt संबंधित अनुक्रमित की खोज में मेटा ऑब्जेक्ट की पंक्ति तालिकाओं को स्कैन करेगा। फिर, एक QObjectPStreet :: कनेक्शन ऑब्जेक्ट बनाया जाता है और आंतरिक सूचियों में जोड़ा जाता है।

प्रत्येक कनेक्शन को संग्रहीत करने के लिए क्या जानकारी आवश्यक है? हमें दिए गए सिग्नल इंडेक्स के लिए कनेक्शन को जल्दी से एक्सेस करने का एक तरीका चाहिए। चूंकि एक ही सिग्नल से कई स्लॉट जुड़े हो सकते हैं, इसलिए हमें प्रत्येक सिग्नल के लिए कनेक्टेड स्लॉट्स की एक सूची होनी चाहिए। प्रत्येक कनेक्शन में प्राप्तकर्ता ऑब्जेक्ट और स्लॉट इंडेक्स होना चाहिए। हम यह भी चाहते हैं कि प्राप्तकर्ता के हटाए जाने पर कनेक्शन स्वचालित रूप से हटा दिए जाएं, इसलिए प्रत्येक प्राप्तकर्ता को यह पता होना चाहिए कि वह किससे जुड़ा है ताकि वह कनेक्शन हटा सके।

यहाँ QObjectPStreet :: Qobject_p.h में परिभाषित कनेक्शन है:

 struct QObjectPrivate::Connection { QObject *sender; QObject *receiver; union { StaticMetaCallFunction callFunction; QtPrivate::QSlotObjectBase *slotObj; }; //      ConnectionList Connection *nextConnectionList; //    Connection *next; Connection **prev; QAtomicPointer<const int> argumentTypes; QAtomicInt ref_; ushort method_offset; ushort method_relative; uint signal_index : 27; //    ( QObjectPrivate::signalIndex()) ushort connectionType : 3; // 0 == auto, 1 == direct, 2 == queued, 4 == blocking ushort isSlotObject : 1; ushort ownArgumentTypes : 1; Connection() : nextConnectionList(0), ref_(2), ownArgumentTypes(true) { // ref_ 2        QMetaObject::Connection } ~Connection(); int method() const { return method_offset + method_relative; } void ref() { ref_.ref(); } void deref() { if (!ref_.deref()) { Q_ASSERT(!receiver); delete this; } } }; 

प्रत्येक ऑब्जेक्ट में कनेक्शन की एक सरणी होती है: यह एक सरणी है जो प्रत्येक सिग्नल को QObjectPrivate :: कनेक्शन सूची से जोड़ता है। प्रत्येक ऑब्जेक्ट में स्वचालित विलोपन के लिए जुड़ी वस्तुओं के कनेक्शन की उलटी सूची भी होती है। यह एक डबल लिंक की गई सूची है।

लिंक की गई सूचियों का उपयोग वस्तुओं को जल्दी से जोड़ने और हटाने के लिए किया जाता है। वे QObjectPrivate :: कनेक्शन के अंदर अगले / पिछले नोड के लिए पॉइंटर्स के साथ कार्यान्वित किए जाते हैं। ध्यान दें कि प्रेषक से प्राप्त सूचक एक सूचक के लिए एक सूचक है। इसका कारण यह है कि हम वास्तव में पिछले नोड की ओर इशारा नहीं करते हैं, बल्कि अगले नोड के लिए। इस सूचक का उपयोग केवल तब किया जाता है जब कनेक्शन टूट जाता है। यह आपको पहले तत्व के लिए एक विशेष मामला नहीं करने की अनुमति देता है।

संकेत उत्सर्जन

जब हम सिग्नल को कॉल करते हैं, तो हमने देखा कि यह MOC द्वारा उत्पन्न कोड को कॉल करता है, जो पहले से ही QMetaObject :: कॉल को सक्रिय करता है । यहाँ qobject.cpp में इस विधि का कार्यान्वयन (नोट्स के साथ) किया गया है:

 void QMetaObject::activate(QObject *sender, const QMetaObject *m, int local_signal_index, void **argv) { /*      ,     */ activate(sender, QMetaObjectPrivate::signalOffset(m), local_signal_index, argv); } void QMetaObject::activate(QObject *sender, int signalOffset, int local_signal_index, void **argv) { int signal_index = signalOffset + local_signal_index; /*      64 ,   0,  ,            ,          */ if (!sender->d_func()->isSignalConnected(signal_index)) return; //      /* …     QML ,   ... */ /*  ,      connectionLists  */ QMutexLocker locker(signalSlotLock(sender)); /*  connectionList   ( ) */ QObjectConnectionListVector *connectionLists = sender->d_func()->connectionLists; const QObjectPrivate::ConnectionList *list = &connectionLists->at(signal_index); QObjectPrivate::Connection *c = list->first; if (!c) continue; //    last,  ,       ,    QObjectPrivate::Connection *last = list->last; /* ,    */ do { if (!c->receiver) continue; QObject * const receiver = c->receiver; const bool receiverInSameThread = QThread::currentThreadId() == receiver->d_func()->threadData->threadId; //       ,      if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread) || (c->connectionType == Qt::QueuedConnection)) { /*       */ queued_activate(sender, signal_index, c, argv); continue; } else if (c->connectionType == Qt::BlockingQueuedConnection) { /* ...  ... */ continue; } /*  ,   sender()   ,     */ QConnectionSenderSwitcher sw; if (receiverInSameThread) sw.switchSender(receiver, sender, signal_index); const QObjectPrivate::StaticMetaCallFunction callFunction = c->callFunction; const int method_relative = c->method_relative; if (c->isSlotObject) { /* …  …  Qt5      ... */ } else if (callFunction && c->method_offset <= receiver->metaObject()->methodOffset()) { /*    callFunction (  qt_static_metacall,  MOC),    */ /*   ,   metodOffset  (    ) */ locker.unlock(); //          callFunction(receiver, QMetaObject::InvokeMetaMethod, method_relative, argv); locker.relock(); } else { /*      */ const int method = method_relative + c->method_offset; locker.unlock(); metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv); locker.relock(); } // ,        if (connectionLists->orphaned) break; } while (c != last && (c = c->nextConnectionList) != 0); } 

UPD : यहां दूसरे भाग का अनुवाद।