Qt 5.11 - QObject (class)

QObject कक्षा




qt

QObject कक्षा

QObject क्लास सभी Qt ऑब्जेक्ट्स का बेस क्लास है। More...

हैडर: # अलग करें <QObject>
qmake: क्यूटी + = कोर
इनहेरिट किया गया:

QAbstractAnimation , QAbstractEventDispatcher , QAbstractItemModel , QAbstractState , QAbstractTransition , QCoreApplication , QEventLoop , QFileSelector , QFileSystemWatcher , QIODevice , QItemSelectionModel , QLibrary , QMimeData , QObjectCleanupHandler , QPluginLoader , QSettings , QSharedMemory , QSignalMapper , QSocketNotifier , QThread , QThreadPool , QTimeLine , QTimer , QTranslator , और QWinEventNotifier

नोट: इस वर्ग के सभी कार्य reentrant

नोट: ये फ़ंक्शन reentrant भी हैं:

  • connect (const QObject * प्रेषक, const char * संकेत, const QObject * रिसीवर, const char * विधि, Qt :: ConnectionType प्रकार)
  • connect (const QObject * प्रेषक, कास्ट चार * सिग्नल, कॉन्स्ट चार * विधि, Qt :: ConnectionType प्रकार) कास्ट
  • connect (const QObject * प्रेषक, PointerToMemberFunction सिग्नल, const QObject * रिसीवर, PointerToMemberFunction विधि, Qt :: ConnectionType प्रकार)
  • connect (const QObject * प्रेषक, PointerToMemberFunction सिग्नल, फ़नकार फ़ंक्टर)
  • connect (const QObject * प्रेषक, PointerToMemberFunction सिग्नल, const QObject * संदर्भ, फ़नकार फ़ंक्टर, Qt :: ConnectionType प्रकार)
  • disconnect (const QObject * प्रेषक, const char * संकेत, const QObject * रिसीवर, const char * विधि)
  • disconnect (कास्ट चार * सिग्नल, कॉन्स्ट QObject * रिसीवर, कास्ट चार * विधि) कास्ट
  • disconnect (const QObject * प्रेषक, PointerToMemberFunction सिग्नल, const QObject * रिसीवर, PointerToMemberFunction विधि)

गुण

सार्वजनिक कार्य

QObject (QObject * माता-पिता = nullptr)
वास्तविक ~QObject ()
bool blockSignals (बूल ब्लॉक )
const QObjectList और children () कांस्टेबल
QMetaObject :: कनेक्शन connect (const QObject * प्रेषक , कास्ट चार * सिग्नल , कॉन्स्ट चार * विधि , Qt :: ConnectionType type = Qt :: AutoConnection) const
bool disconnect (const char * signal = nullptr, const QObject * रिसीवर = nullptr, const char * विधि = nullptr) const
bool disconnect (const QObject * रिसीवर , const char * पद्धति = nullptr) कास्ट
शून्य dumpObjectInfo () dumpObjectInfo
शून्य dumpObjectTree () dumpObjectTree
QList <QByteArray> dynamicPropertyNames () dynamicPropertyNames
आभासी बूल event (QEvent * e )
आभासी बूल eventFilter (QObject * देखा , QEvent * घटना )
टी findChild (const findChild & name = QString) (, Qt :: FindChildOptions options = Qt :: FindChildrenRecursively) const
QList <टी> findChildren (const findChildren & name = QString) (, Qt :: FindChildOptions options = Qt :: FindChildrenRecursively) const
QList <टी> findChildren (const QRegExp & regExp , Qt :: FindChildOptions options = Qt :: FindChildrenRecursively) const
QList <टी> findChildren (const QRegularExpression & re , Qt :: FindChildOptions Options = Qt :: FindChildrenRecursively) const
bool inherits (const char * className ) कांस्टेबल
शून्य installEventFilter (QObject * filterObj )
bool isWidgetType () const
bool isWindowType () const
शून्य killTimer (इंट आईडी )
वर्चुअल कास्ट QMetaObject * metaObject () const
शून्य moveToThread ( moveToThread * moveToThread )
QString objectName () const
QObject * parent () कांस्टेबल
QVariant property (कास्ट चार * नाम ) कास्ट
शून्य removeEventFilter (QObject * obj )
शून्य objectName (const objectName और नाम )
शून्य setParent (QObject * माता-पिता )
bool setProperty (कास्ट चार * नाम , कास्ट QVariant और मूल्य )
bool signalsBlocked () const
पूर्णांक startTimer (int अंतराल , Qt :: टाइमर टाइप टाइमर = Qt :: CoarseTimer)
पूर्णांक startTimer (std :: chrono :: मिलीसेकंड समय , Q :: टाइमर टाइमर टाइमर = Qt :: CoarseTimer)
* thread () कांस्टेबल

सार्वजनिक स्लॉट

शून्य deleteLater ()

सिग्नल

शून्य destroyed (QObject * obj = nullptr)
शून्य objectNameChanged (const QString और objectName )

स्थैतिक जन सदस्य

QMetaObject :: कनेक्शन connect (const QObject * प्रेषक , const char * सिग्नल , const QObject * रिसीवर , const char * विधि , Qt :: ConnectionType प्रकार = Qt :: AutoConnection)
QMetaObject :: कनेक्शन connect (const QObject * प्रेषक , const QMetaMethod & सिग्नल , const QObject * रिसीवर , const QMetaMethod & पद्धति , Qt :: ConnectionType प्रकार = Qt :: AutoConnection)
QMetaObject :: कनेक्शन connect (const QObject * प्रेषक , PointerToMemberFunction सिग्नल , const QObject * रिसीवर , PointerToMemberFunction विधि , Qt :: ConnectionType प्रकार = Qt :: AutoConnection)
QMetaObject :: कनेक्शन connect (const QObject * प्रेषक , PointerToMemberFunction सिग्नल , फ़नकार फ़ंक्टर)
QMetaObject :: कनेक्शन connect (const QObject * प्रेषक , PointerToMemberFunction सिग्नल , कॉन्स्टेंस QObject * संदर्भ , फ़नकार फ़ंक्टर, Qt :: ConnectionType type = Qt :: AutoConnection)
bool disconnect (const QObject * प्रेषक , const char * संकेत , const QObject * रिसीवर , const char * विधि )
bool disconnect (const QObject * प्रेषक , const QMetaMethod & सिग्नल , const QObject * रिसीवर , const QMetaMethod & पद्धति )
bool disconnect (const QMetaObject :: कनेक्शन और कनेक्शन )
bool disconnect (const QObject * प्रेषक , PointerToMemberFunction सिग्नल , const QObject * रिसीवर , PointerToMemberFunction विधि )
const QMetaObject staticMetaObject
QString tr (const char * sourceText , const char * disambiguation = Q_OBJECT, int n = Q_OBJECT)

संरक्षित कार्य

आभासी शून्य childEvent (QChildEvent * घटना )
आभासी शून्य connectNotify (const QMetaMethod & signal )
आभासी शून्य customEvent (QEvent * घटना )
आभासी शून्य disconnectNotify (const QMetaMethod & signal )
bool isSignalConnected (const QMetaMethod & सिग्नल ) const
पूर्णांक receivers (कास्ट चार * सिग्नल ) कास्ट
QObject * sender () कांस्टेबल
पूर्णांक senderSignalIndex () const
आभासी शून्य timerEvent (QTimerEvent * घटना )
typedef QObjectList
QList <टी> qFindChildren (const QObject * obj , const QRegExp & regExp )
टी qobject_cast (QObject * ऑब्जेक्ट )
टी qobject_cast (const QObject * ऑब्जेक्ट )

मैक्रो

QT_NO_NARROWING_CONVERSIONS_IN_CONNECT
Q_CLASSINFO ( नाम , मान )
Q_DISABLE_COPY ( कक्षा )
Q_EMIT
Q_ENUM ( ... )
Q_ENUM_NS ( ... )
Q_FLAG ( ... )
Q_FLAG_NS ( ... )
Q_GADGET
Q_INTERFACES ( ... )
Q_INVOKABLE
Q_NAMESPACE
Q_OBJECT
Q_PROPERTY ( ... )
Q_REVISION
Q_SET_OBJECT_NAME ( ऑब्जेक्ट )
Q_SIGNAL
Q_SIGNALS
Q_SLOT
Q_SLOTS

विस्तृत विवरण

QObject क्लास सभी Qt ऑब्जेक्ट्स का बेस क्लास है।

QObject Qt ऑब्जेक्ट मॉडल का दिल है। इस मॉडल में केंद्रीय विशेषता सीमलेस ऑब्जेक्ट कम्युनिकेशन के लिए बहुत शक्तिशाली तंत्र है, जिसे सिग्नल और स्लॉट कहा जाता है । आप connect () के साथ एक स्लॉट में एक सिग्नल कनेक्ट कर सकते हैं और disconnect () के साथ कनेक्शन को नष्ट कर सकते हैं। अधिसूचना छोरों को कभी समाप्त न करने के लिए, आप अस्थायी रूप से blockSignals () के साथ संकेतों को ब्लॉक कर सकते हैं। संरक्षित कार्य connectNotify () और disconnectNotify (कनेक्ट) कनेक्शन को ट्रैक करना संभव बनाते हैं।

QObjects खुद को ऑब्जेक्ट ट्री में व्यवस्थित करते हैं । जब आप माता-पिता के रूप में किसी अन्य ऑब्जेक्ट के साथ एक QObject बनाते हैं, तो ऑब्जेक्ट स्वचालित रूप से स्वयं को माता-पिता के children () सूची में जोड़ देगा। अभिभावक वस्तु का स्वामित्व लेता है; यानी, यह अपने बच्चों को अपने विध्वंसक रूप से हटा देगा। आप किसी ऑब्जेक्ट के लिए नाम और वैकल्पिक रूप से findChild () या findChildren () का उपयोग करके findChild

प्रत्येक ऑब्जेक्ट में एक objectName नाम () होता है और इसके वर्ग का नाम संबंधित metaObject () ( QMetaObject::className () देखें) के माध्यम से पाया जा सकता है। आप यह निर्धारित कर सकते हैं कि ऑब्जेक्ट का वर्ग QObject वंशानुक्रम पदानुक्रम में किसी अन्य वर्ग को inherits () फ़ंक्शन का उपयोग करके inherits में inherits है या नहीं।

जब कोई ऑब्जेक्ट हटा दिया जाता है, तो यह destroyed () सिग्नल का उत्सर्जन करता है। QObjects के झूलते संदर्भों से बचने के लिए आप इस सिग्नल को पकड़ सकते हैं।

QObjects event () के माध्यम से event प्राप्त कर सकते हैं और अन्य ऑब्जेक्ट्स की घटनाओं को फ़िल्टर कर सकते हैं। विवरण के लिए eventFilter () और eventFilter () देखें। बच्चे की घटनाओं को पकड़ने के लिए एक सुविधा हैंडलर, childEvent () को फिर से लागू किया जा सकता है।

अंतिम लेकिन कम से कम नहीं, QObject Qt में मूल टाइमर समर्थन प्रदान करता है; QTimer को टाइमर के लिए उच्च-स्तरीय समर्थन के लिए देखें।

ध्यान दें कि Q_OBJECT मैक्रो सिग्नल, स्लॉट या गुणों को लागू करने वाली किसी भी वस्तु के लिए अनिवार्य है। आपको स्रोत फ़ाइल पर मेटा ऑब्जेक्ट कंपाइलर को चलाने की भी आवश्यकता है। हम QObject सभी उपवर्गों में इस मैक्रो के उपयोग की दृढ़ता से अनुशंसा करते हैं, भले ही वे वास्तव में सिग्नल, स्लॉट और गुणों का उपयोग करें या नहीं, क्योंकि ऐसा करने में विफलता के कारण कुछ कार्य अजीब व्यवहार का प्रदर्शन कर सकते हैं।

सभी Qt विजेट QObject विरासत में QObject । सुविधा फ़ंक्शन isWidgetType () देता है कि क्या कोई ऑब्जेक्ट वास्तव में एक विजेट है। यह qobject_cast < QWidget *> ( obj ) या obj -> inherits (" QWidget ") की तुलना में बहुत तेज़ है।

कुछ QObject फ़ंक्शन, जैसे children (), एक QObjectList QObjectList QList < QObject *> के लिए एक QObjectList है।

धागा आत्मीयता

एक QObject उदाहरण के लिए एक धागा संबंध है , या यह कि यह एक निश्चित धागे में रहता है। जब QObject एक कतारबद्ध संकेत या एक पोस्ट की गई घटना प्राप्त करता है, तो स्लॉट या ईवेंट हैंडलर उस थ्रेड में चलेगा, जिसमें ऑब्जेक्ट रहता है।

नोट: यदि किसी QObject में कोई थ्रेड QObject नहीं है (यानी, thread () शून्य लौटता है), या यदि यह उस थ्रेड में रहता है जिसमें कोई रनिंग इवेंट लूप नहीं है, तो यह कतारबद्ध सिग्नल या पोस्ट किए गए ईवेंट प्राप्त नहीं कर सकता है।

डिफ़ॉल्ट रूप से, एक QObject उस थ्रेड में रहता है जिसमें इसे बनाया गया है। एक वस्तु के धागे की आत्मीयता को thread () और moveToThread का उपयोग करके परिवर्तित किया जा सकता है।

सभी QObjects को अपने माता-पिता के समान सूत्र में रहना चाहिए। इसके फलस्वरूप:

  • अगर दो QObjects अलग थ्रेड में रहते हैं तो setParent () विफल हो जाएगा।
  • जब एक QObject को दूसरे धागे में ले जाया जाता है, तो उसके सभी बच्चे अपने आप चले जाएंगे।
  • moveToThread () विफल हो जाएगा यदि QObject पास माता-पिता हैं।
  • यदि QObjects QThread QThread::run () के भीतर बनाए जाते हैं, तो वे QThread ऑब्जेक्ट के बच्चे नहीं बन सकते, क्योंकि QThread उस थ्रेड में नहीं रहता है जो QThread::run () कहता है।

नोट: एक QObject के सदस्य चर स्वचालित रूप से इसके बच्चे नहीं बनते हैं। माता-पिता के बच्चे के संबंध को या तो बच्चे के QObject को पॉइंटर पास करके या setParent () कहकर निर्धारित किया जाना चाहिए। इस चरण के बिना, ऑब्जेक्ट के सदस्य चर पुराने धागे में moveToThread जब moveToThread () कहा जाता है।

कोई कॉपी कंस्ट्रक्टर या असाइनमेंट ऑपरेटर नहीं

QObject पास न तो कॉपी कंस्ट्रक्टर है और न ही असाइनमेंट ऑपरेटर। यह डिजाइन द्वारा है। दरअसल, वे घोषित हैं, लेकिन मैक्रो Q_DISABLE_COPY () के साथ एक private अनुभाग में। वास्तव में, QObject (प्रत्यक्ष या अप्रत्यक्ष) से ​​प्राप्त सभी Qt वर्ग इस मैक्रो का उपयोग अपने कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटर को निजी घोषित करने के लिए करते हैं। यह तर्क Qt ऑब्जेक्ट मॉडल पृष्ठ पर पहचान बनाम मूल्य पर चर्चा में पाया जाता है।

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

स्वत: कनेक्शन

Qt का मेटा-ऑब्जेक्ट सिस्टम QObject उपवर्गों और उनके बच्चों के बीच संकेतों और स्लॉट को स्वचालित रूप से जोड़ने के लिए एक तंत्र प्रदान करता है। जब तक वस्तुओं को उपयुक्त वस्तु नामों से परिभाषित किया जाता है, और स्लॉट एक सरल नामकरण सम्मेलन का पालन करते हैं, इस कनेक्शन को QMetaObject::connectSlotsByName () फ़ंक्शन द्वारा रन-टाइम पर किया जा सकता है।

uic कोड उत्पन्न करता है जो इस फ़ंक्शन को क्यूटी डिज़ाइनर के साथ बनाए गए फ़ॉर्म पर विगेट्स के बीच ऑटो-कनेक्शन को सक्षम करने के लिए आमंत्रित करता है। Qt डिजाइनर के साथ ऑटो-कनेक्शन का उपयोग करने के बारे में अधिक जानकारी Qt डिजाइनर मैनुअल के आपके एप्लिकेशन अनुभाग में एक डिजाइनर UI फ़ाइल का उपयोग करने में दी गई है।

गतिशील गुण

क्यूटी 4.2 से, गतिशील गुणों को जोड़ा जा सकता है और रन-टाइम पर QObject उदाहरणों से हटाया जा सकता है। गतिशील गुणों को संकलन-समय पर घोषित करने की आवश्यकता नहीं है, फिर भी वे स्थैतिक गुणों के समान लाभ प्रदान करते हैं और उन्हें लिखने के लिए समान एपीआई - property () का उपयोग करके और उन्हें लिखने के लिए setProperty () का उपयोग करके हेरफेर किया जाता है।

क्यूटी 4.3 से, गतिशील गुणों को क्यूटी डिजाइनर द्वारा समर्थित किया जाता है , और दोनों मानक क्यूटी विजेट और उपयोगकर्ता-निर्मित रूपों को गतिशील गुण दिए जा सकते हैं।

अंतर्राष्ट्रीयकरण (I18n)

सभी QObject उपवर्ग Qt की अनुवाद सुविधाओं का समर्थन करते हैं, जिससे किसी एप्लिकेशन के उपयोगकर्ता इंटरफ़ेस का विभिन्न भाषाओं में अनुवाद करना संभव हो जाता है।

उपयोगकर्ता-दृश्य पाठ को अनुवाद योग्य बनाने के लिए, इसे tr () फ़ंक्शन में कॉल में लपेटा जाना चाहिए। यह अनुवाद दस्तावेज़ के लिए लेखन स्रोत कोड में विस्तार से बताया गया है।

QPointer , QPointer , QObjectCleanupHandler , Q_DISABLE_COPY (), और ऑब्जेक्ट ट्रीज़ और ओनरशिप भी देखें

संपत्ति का प्रलेखन

ऑब्जेक्टनेम : QString

यह गुण इस ऑब्जेक्ट का नाम रखता है

आप findChild () का उपयोग करके नाम (और प्रकार) द्वारा एक ऑब्जेक्ट पा सकते हैं। आप findChildren () के साथ ऑब्जेक्ट्स का एक सेट पा सकते हैं।

qDebug("MyClass::setPrecision(): (%s) invalid precision %f",
       qPrintable(objectName()), newPrecision);

डिफ़ॉल्ट रूप से, इस गुण में एक रिक्त स्ट्रिंग होती है।

पहुंच कार्य:

QString objectName () const
शून्य setObjectName (const QString और नाम )

नोटिफ़ायर सिग्नल:

शून्य objectNameChanged (const QString और objectName ) [नीचे दिए गए नोट देखें]

नोट: यह एक निजी संकेत है। इसका उपयोग सिग्नल कनेक्शन में किया जा सकता है लेकिन उपयोगकर्ता द्वारा उत्सर्जित नहीं किया जा सकता है।

metaObject () और QMetaObject::className () भी देखें

सदस्य समारोह प्रलेखन

QObject :: QObject ( QObject * जनक = nullptr)

मूल वस्तु माता- पिता के साथ एक वस्तु का निर्माण करती है।

किसी ऑब्जेक्ट के माता-पिता को ऑब्जेक्ट के स्वामी के रूप में देखा जा सकता है। उदाहरण के लिए, एक संवाद बॉक्स ओके का अभिभावक होता है और उसमें मौजूद बटन को रद्द कर देता है।

माता-पिता की वस्तु का विनाश सभी बाल वस्तुओं को नष्ट कर देता है।

अभिभावक को 0 पर सेट करने से कोई अभिभावक नहीं बनता है। यदि ऑब्जेक्ट एक विजेट है, तो यह एक शीर्ष-स्तरीय विंडो बन जाएगा।

नोट: यह फ़ंक्शन मेटा-ऑब्जेक्ट सिस्टम के माध्यम से और QML से मंगवाया जा सकता है। Q_INVOKABLE देखें।

parent (), findChild (), और findChildren () भी देखें।

[virtual] QObject :: ~ QObject ()

ऑब्जेक्ट को नष्ट कर देता है, उसके सभी चाइल्ड ऑब्जेक्ट को हटा देता है।

ऑब्जेक्ट के सभी सिग्नल स्वचालित रूप से डिस्कनेक्ट हो जाते हैं, और ऑब्जेक्ट के लिए किसी भी लंबित पोस्ट इवेंट को इवेंट कतार से हटा दिया जाता है। हालाँकि, अक्सर किसी QObject उपवर्ग को सीधे हटाने के बजाय deleteLater () का उपयोग करना अधिक सुरक्षित होता है।

चेतावनी: सभी बाल वस्तुओं को हटा दिया जाता है। यदि इनमें से कोई भी वस्तु स्टैक या ग्लोबल पर है, तो जल्द या बाद में आपका प्रोग्राम क्रैश हो जाएगा। हम माता-पिता के बाहर से बच्चे की वस्तुओं को इंगित करने की सलाह नहीं देते हैं। यदि आप अभी भी करते हैं, तो destroyed () संकेत आपको एक वस्तु नष्ट होने पर पता लगाने का अवसर देता है।

चेतावनी: लंबित घटनाओं को डिलीट किए जाने की प्रतीक्षा में एक QObject को हटाने से दुर्घटना हो सकती है। यदि आप वर्तमान में निष्पादित की तुलना में किसी भिन्न थ्रेड में मौजूद है, तो QObject सीधे QObject को नहीं हटाना चाहिए। इसके बजाय deleteLater () का उपयोग करें, जो सभी लंबित घटनाओं को उस पर वितरित करने के बाद ऑब्जेक्ट को हटाने के लिए ईवेंट लूप का कारण होगा।

deleteLater () भी देखें

बूल QObject :: ब्लॉकसिग्नल्स ( बूल ब्लॉक )

यदि ब्लॉक सत्य है, तो इस ऑब्जेक्ट द्वारा उत्सर्जित सिग्नल ब्लॉक किए गए हैं (यानी, सिग्नल को उत्सर्जित करने से इससे जुड़ी कोई भी चीज नहीं निकलेगी)। यदि ब्लॉक गलत है, तो ऐसी कोई भी ब्लॉकिंग नहीं होगी।

वापसी का मूल्य signalsBlocked के पिछले मूल्य है ()।

ध्यान दें कि destroyed () सिग्नल को उत्सर्जित किया जाएगा भले ही इस ऑब्जेक्ट के लिए सिग्नल अवरुद्ध हो गए हों।

अवरुद्ध होने के दौरान उत्सर्जित सिग्नल बफ़र्ड नहीं होते हैं।

signalsBlocked भी देखें ( signalsBlocked ) और QSignalBlocker

[virtual protected] शून्य QObject :: childEvent ( QChildEvent * घटना )

इस ईवेंट हैंडलर को बाल कार्यक्रमों को प्राप्त करने के लिए एक उपवर्ग में फिर से लागू किया जा सकता है। ईवेंट पैरामीटर में इवेंट पास किया जाता है।

QEvent::ChildAdded और QEvent::ChildAdded इवेंट बच्चों को जोड़े या हटाए जाने पर वस्तुओं को भेजे जाते हैं। दोनों ही मामलों में आप केवल एक बच्चे के QObject होने पर भरोसा कर सकते हैं, या यदि isWidgetType () true , तो एक QWidget । (ऐसा इसलिए है, क्योंकि चाइल्ड QEvent::ChildAdded मामले में, बच्चा अभी तक पूरी तरह से निर्मित नहीं है, और QEvent::ChildAdded केस में यह पहले से ही नष्ट हो चुका होगा)।

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

प्रत्येक चाइल्ड विजेट के लिए, आपको एक QEvent::ChildAdded ईवेंट, शून्य या अधिक QEvent::ChildAdded इवेंट और एक QEvent::ChildAdded इवेंट प्राप्त होता है।

QEvent::ChildAdded की QEvent::ChildAdded घटना को छोड़ दिया जाता है, अगर एक बच्चे को जोड़ने के तुरंत बाद हटा दिया जाता है। यदि एक बच्चे को निर्माण और विनाश के दौरान कई बार पॉलिश किया जाता है, तो आप एक ही बच्चे के लिए कई बार बच्चे की पॉलिश की हुई घटनाओं को प्राप्त कर सकते हैं, हर बार एक अलग वर्चुअल टेबल के साथ।

event () भी देखें

const QObjectList और QObject :: बच्चे () const

बाल वस्तुओं की सूची लौटाता है। QObjectList वर्ग को <QObject> हेडर फ़ाइल में निम्नलिखित के रूप में परिभाषित किया गया है:

typedef QList<QObject*> QObjectList;

जोड़ा गया पहला बच्चा सूची में first वस्तु है और जोड़ा गया अंतिम बच्चा सूची में last वस्तु है, अर्थात नए बच्चों को अंत में जोड़ा जाता है।

ध्यान दें कि जब QWidget बच्चों को raised या lowered जाता है तो सूची क्रम बदल जाता है। एक विजेट जो उठाया जाता है वह सूची में अंतिम ऑब्जेक्ट बन जाता है, और एक विजेट जो कम होता है वह सूची में पहला ऑब्जेक्ट बन जाता है।

findChild (), findChildren (), parent (), और setParent () भी देखें।

[static] QMetaObject QMetaObject::Connection QObject :: कनेक्ट (const QObject * प्रेषक , QObject चार * संकेत , QObject * रिसीवर , QObject चार * विधि , Qt :: ConnectionType type = Qt :: Autobonnection)

रिसीवर ऑब्जेक्ट में विधि में प्रेषक ऑब्जेक्ट में सिग्नल से दिए गए प्रकार का एक कनेक्शन बनाता है। उस कनेक्शन के हैंडल को देता है जिसे बाद में डिस्कनेक्ट करने के लिए उपयोग किया जा सकता है।

संकेत और विधि निर्दिष्ट करते समय आपको SIGNAL() और SLOT() मैक्रो का उपयोग करना चाहिए, उदाहरण के लिए:

QLabel *label = new QLabel;
QScrollBar *scrollBar = new QScrollBar;
QObject::connect(scrollBar, SIGNAL(valueChanged(int)),
                 label,  SLOT(setNum(int)));

यह उदाहरण सुनिश्चित करता है कि लेबल हमेशा वर्तमान स्क्रॉल बार मान प्रदर्शित करता है। ध्यान दें कि सिग्नल और स्लॉट पैरामीटर में कोई चर नाम नहीं होना चाहिए, केवल प्रकार। उदाहरण के लिए, निम्नलिखित काम नहीं करेगा और गलत लौटेगा:

// WRONG
QObject::connect(scrollBar, SIGNAL(valueChanged(int value)),
                 label, SLOT(setNum(int value)));

एक सिग्नल को दूसरे सिग्नल से भी जोड़ा जा सकता है:

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget();

signals:
    void buttonClicked();

private:
    QPushButton *myButton;
};

MyWidget::MyWidget()
{
    myButton = new QPushButton(this);
    connect(myButton, SIGNAL(clicked()),
            this, SIGNAL(buttonClicked()));
}

इस उदाहरण में, MyWidget निर्माणकर्ता निजी सदस्य चर से एक संकेत देता है, और इसे एक नाम के तहत उपलब्ध कराता है जो MyWidget से संबंधित है।

एक सिग्नल को कई स्लॉट और सिग्नल से जोड़ा जा सकता है। कई संकेतों को एक स्लॉट से जोड़ा जा सकता है।

यदि कोई संकेत कई स्लॉट्स से जुड़ा है, तो स्लॉट उसी क्रम में सक्रिय होते हैं, जिसमें सिग्नल उत्सर्जित होने पर कनेक्शन बनाए जाते थे।

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

डिफ़ॉल्ट रूप से, आपके द्वारा किए गए प्रत्येक कनेक्शन के लिए एक सिग्नल उत्सर्जित होता है; डुप्लिकेट कनेक्शन के लिए दो सिग्नल उत्सर्जित होते हैं। आप एकल disconnect () कॉल के साथ इन सभी कनेक्शनों को तोड़ सकते हैं। यदि आप Qt :: UniqueConnection टाइप पास करते हैं, तो कनेक्शन केवल तभी बनाया जाएगा जब वह डुप्लिकेट नहीं होगा। यदि पहले से ही एक डुप्लिकेट (समान वस्तुओं पर सटीक समान स्लॉट के लिए सटीक संकेत) है, तो कनेक्शन विफल हो जाएगा और कनेक्ट अमान्य QMetaObject::Connection वापस कर देगा।

नोट: Qt :: UniqueConnections लैंबडास, गैर-सदस्य कार्यों और फंक्शनलर्स के लिए काम नहीं करते हैं; वे केवल सदस्य कार्यों से जुड़ने के लिए आवेदन करते हैं।

वैकल्पिक प्रकार पैरामीटर स्थापित करने के लिए कनेक्शन के प्रकार का वर्णन करता है। विशेष रूप से, यह निर्धारित करता है कि क्या किसी विशेष सिग्नल को तुरंत स्लॉट में वितरित किया जाता है या बाद के समय में डिलीवरी के लिए कतारबद्ध किया जाता है। यदि संकेत पंक्तिबद्ध है, तो पैरामीटर उन प्रकारों के होने चाहिए जो Qt के मेटा-ऑब्जेक्ट सिस्टम के लिए जाने जाते हैं, क्योंकि Qt को पर्दे के पीछे एक घटना में संग्रहीत करने के लिए तर्कों को कॉपी करने की आवश्यकता होती है। यदि आप एक पंक्तिबद्ध कनेक्शन का उपयोग करने का प्रयास करते हैं और त्रुटि संदेश प्राप्त करते हैं

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

कनेक्शन स्थापित करने से पहले डेटा प्रकार को पंजीकृत करने के लिए qRegisterMetaType () को कॉल करें।

नोट: यह फ़ंक्शन reentrant

disconnect (), sender (), qRegisterMetaType (), Q_DECLARE_METATYPE (), और स्ट्रिंग-आधारित और फ़नर-आधारित कनेक्शन के बीच अंतर भी देखें

[static] QMetaObject QMetaObject::Connection QObject :: कनेक्ट (const QObject * प्रेषक , QMetaMethod & सिग्नल , QObject * रिसीवर , const QMetaMethod & method , Qt - ConnectionType type = Qt :: AutoConnection)

रिसीवर ऑब्जेक्ट में विधि में प्रेषक ऑब्जेक्ट में सिग्नल से दिए गए प्रकार का एक कनेक्शन बनाता है। उस कनेक्शन के हैंडल को देता है जिसे बाद में डिस्कनेक्ट करने के लिए उपयोग किया जा सकता है।

कनेक्शन हैंडल अमान्य होगा यदि यह कनेक्शन नहीं बना सकता है, उदाहरण के लिए, पैरामीटर अमान्य थे। आप जाँच सकते हैं कि क्या QMetaObject::Connection एक बूल में डालने से वैध है।

यह फ़ंक्शन connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) QMetaMethod करता है, लेकिन यह सिग्नल और विधि को निर्दिष्ट करने के लिए QMetaMethod का उपयोग करता है।

यह फ़ंक्शन Qt 4.8 में पेश किया गया था।

connect (const QObject * प्रेषक, const char * सिग्नल, const QObject * रिसीवर, const char * पद्धति, Qt :: ConnectionType प्रकार) भी देखें।

QMetaObject QMetaObject::Connection QObject :: कनेक्ट (const QObject * प्रेषक , QObject चार * सिग्नल , QObject चार * विधि , Qt :: ConnectionType प्रकार = Qt :: AutoConnection) कॉन्स्ट

यह फ़ंक्शन ओवरलोड connect () करता है।

प्रेषक ऑब्जेक्ट से इस ऑब्जेक्ट की विधि से संकेत जोड़ता है।

कनेक्ट करने के लिए बराबर ( प्रेषक , संकेत , this , विधि , प्रकार )।

आपके द्वारा बनाया गया प्रत्येक कनेक्शन एक सिग्नल का उत्सर्जन करता है, इसलिए डुप्लिकेट कनेक्शन दो सिग्नल का उत्सर्जन करते हैं। आप disconnect () का उपयोग करके कनेक्शन तोड़ सकते हैं।

नोट: यह फ़ंक्शन reentrant

disconnect () भी देखें

[static] QMetaObject QMetaObject::Connection QObject :: कनेक्ट (const QObject * प्रेषक , PointerToMemberFunction सिग्नल , QObject * रिसीवर , PointerToMemberFunction विधि , Qt :: ConnectionType प्रकार = Qt :: AutoConnection)

यह फ़ंक्शन ओवरलोड connect () करता है।

रिसीवर ऑब्जेक्ट में विधि में प्रेषक ऑब्जेक्ट में सिग्नल से दिए गए प्रकार का एक कनेक्शन बनाता है। उस कनेक्शन के हैंडल को देता है जिसे बाद में डिस्कनेक्ट करने के लिए उपयोग किया जा सकता है।

सिग्नल को हेडर में सिग्नल के रूप में घोषित फ़ंक्शन होना चाहिए। स्लॉट फ़ंक्शन किसी भी सदस्य फ़ंक्शन हो सकता है जो सिग्नल से जुड़ा हो सकता है। एक स्लॉट किसी दिए गए सिग्नल से जुड़ा हो सकता है यदि सिग्नल में कम से कम तर्क के रूप में स्लॉट है, और सिग्नल और स्लॉट में संबंधित तर्कों के प्रकारों के बीच एक अंतर्निहित रूपांतरण है।

उदाहरण:

QLabel *label = new QLabel;
QLineEdit *lineEdit = new QLineEdit;
QObject::connect(lineEdit, &QLineEdit::textChanged,
                 label,  &QLabel::setText);

यह उदाहरण सुनिश्चित करता है कि लेबल हमेशा वर्तमान पंक्ति संपादन पाठ प्रदर्शित करता है।

एक सिग्नल को कई स्लॉट और सिग्नल से जोड़ा जा सकता है। कई संकेतों को एक स्लॉट से जोड़ा जा सकता है।

यदि कोई सिग्नल कई स्लॉट्स से जुड़ा है, तो स्लॉट उसी क्रम में सक्रिय होते हैं, जिस तरह से ऑर्डर तब किया जाता था, जब सिग्नल उत्सर्जित होता है

फ़ंक्शन कनेक्शन के लिए एक हैंडल देता है यदि यह सफलतापूर्वक सिग्नल को स्लॉट से जोड़ता है। कनेक्शन हैंडल अमान्य हो जाएगा यदि यह कनेक्शन नहीं बना सकता है, उदाहरण के लिए, यदि QObject सिग्नल के अस्तित्व को सत्यापित करने में असमर्थ है (यदि इसे सिग्नल के रूप में घोषित नहीं किया गया था) तो आप जाँच सकते हैं कि क्या QMetaObject::Connection इसे कास्टिंग द्वारा मान्य है एक बूल को।

डिफ़ॉल्ट रूप से, आपके द्वारा किए गए प्रत्येक कनेक्शन के लिए एक सिग्नल उत्सर्जित होता है; डुप्लिकेट कनेक्शन के लिए दो सिग्नल उत्सर्जित होते हैं। आप एकल disconnect () कॉल के साथ इन सभी कनेक्शनों को तोड़ सकते हैं। यदि आप Qt :: UniqueConnection टाइप पास करते हैं, तो कनेक्शन केवल तभी बनाया जाएगा जब वह डुप्लिकेट नहीं होगा। यदि पहले से ही एक डुप्लिकेट (समान वस्तुओं पर सटीक समान स्लॉट के लिए सटीक संकेत) है, तो कनेक्शन विफल हो जाएगा और कनेक्ट अमान्य QMetaObject::Connection वापस कर देगा।

वैकल्पिक प्रकार पैरामीटर स्थापित करने के लिए कनेक्शन के प्रकार का वर्णन करता है। विशेष रूप से, यह निर्धारित करता है कि क्या किसी विशेष सिग्नल को तुरंत स्लॉट में वितरित किया जाता है या बाद के समय में डिलीवरी के लिए कतारबद्ध किया जाता है। यदि संकेत पंक्तिबद्ध है, तो पैरामीटर उन प्रकारों के होने चाहिए जो Qt के मेटा-ऑब्जेक्ट सिस्टम के लिए जाने जाते हैं, क्योंकि Qt को पर्दे के पीछे एक घटना में संग्रहीत करने के लिए तर्कों को कॉपी करने की आवश्यकता होती है। यदि आप एक पंक्तिबद्ध कनेक्शन का उपयोग करने का प्रयास करते हैं और त्रुटि संदेश प्राप्त करते हैं

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

Q_DECLARE_METATYPE साथ तर्क प्रकार घोषित करना सुनिश्चित करें

ओवरलोड कार्यों को qOverload मदद से हल किया जा सकता है।

नोट: यह फ़ंक्शन reentrant

स्ट्रिंग-आधारित और फ़नर-आधारित कनेक्शन के बीच अंतर भी देखें

[static] QMetaObject QMetaObject::Connection QObject :: कनेक्ट (const QObject * प्रेषक , PointerToMemberFunction संकेत , फ़नकार फ़ंक्टर )

यह फ़ंक्शन ओवरलोड connect () करता है।

प्रेषक ऑब्जेक्ट में सिग्नल से फ़नकार के लिए एक कनेक्शन बनाता है, और कनेक्शन के लिए एक हैंडल देता है

सिग्नल को हेडर में सिग्नल के रूप में घोषित फ़ंक्शन होना चाहिए। स्लॉट फंक्शन कोई भी फ़ंक्शन या फ़ंक्टर हो सकता है जो सिग्नल से जुड़ा हो सकता है। एक फ़ंक्शन किसी दिए गए सिग्नल से जुड़ा हो सकता है अगर सिग्नल कम से कम स्लॉट के रूप में कई तर्क के रूप में हो। एक फ़नकार को सिग्नल से जोड़ा जा सकता है यदि उनके पास ठीक उसी तरह के तर्क हों। सिग्नल और स्लॉट में संबंधित तर्कों के प्रकारों के बीच अंतर्निहित रूपांतरण मौजूद होना चाहिए।

उदाहरण:

void someFunction();
QPushButton *button = new QPushButton;
QObject::connect(button, &QPushButton::clicked, someFunction);

लैम्ब्डा एक्सप्रेशन का भी उपयोग किया जा सकता है:

QByteArray page = ...;
QTcpSocket *socket = new QTcpSocket;
socket->connectToHost("qt-project.org", 80);
QObject::connect(socket, &QTcpSocket::connected, [=] () {
        socket->write("GET " + page + "\r\n");
    });

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

ओवरलोड कार्यों को qOverload मदद से हल किया जा सकता है।

नोट: यह फ़ंक्शन reentrant

[static] QMetaObject QMetaObject::Connection QObject :: कनेक्ट (const QObject * प्रेषक , PointerToMemberFunction सिग्नल , QObject * संदर्भ , QObject , Qt :: ConnectionType = Qt :: AutoConnection)

यह फ़ंक्शन ओवरलोड connect () करता है।

संदर्भ के एक विशिष्ट ईवेंट लूप में रखे जाने के लिए प्रेषक ऑब्जेक्ट में सिग्नल से संकेत दिए गए प्रकार का एक कनेक्शन बनाता है, और कनेक्शन के लिए एक हैंडल देता है।

नोट: Qt :: UniqueConnections लैंबडास, गैर-सदस्य कार्यों और फंक्शनलर्स के लिए काम नहीं करते हैं; वे केवल सदस्य कार्यों से जुड़ने के लिए आवेदन करते हैं।

सिग्नल को हेडर में सिग्नल के रूप में घोषित फ़ंक्शन होना चाहिए। स्लॉट फंक्शन कोई भी फ़ंक्शन या फ़ंक्टर हो सकता है जो सिग्नल से जुड़ा हो सकता है। एक फ़ंक्शन किसी दिए गए सिग्नल से जुड़ा हो सकता है अगर सिग्नल कम से कम स्लॉट के रूप में कई तर्क के रूप में हो। एक फ़नकार को सिग्नल से जोड़ा जा सकता है यदि उनके पास ठीक उसी तरह के तर्क हों। सिग्नल और स्लॉट में संबंधित तर्कों के प्रकारों के बीच अंतर्निहित रूपांतरण मौजूद होना चाहिए।

उदाहरण:

void someFunction();
QPushButton *button = new QPushButton;
QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);

लैम्ब्डा एक्सप्रेशन का भी उपयोग किया जा सकता है:

QByteArray page = ...;
QTcpSocket *socket = new QTcpSocket;
socket->connectToHost("qt-project.org", 80);
QObject::connect(socket, &QTcpSocket::connected, this, [=] () {
        socket->write("GET " + page + "\r\n");
    }, Qt::AutoConnection);

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

ओवरलोड कार्यों को qOverload मदद से हल किया जा सकता है।

नोट: यह फ़ंक्शन reentrant

यह फ़ंक्शन Qt 5.2 में पेश किया गया था।

[virtual protected] शून्य QObject :: connectNotify (const QMetaMethod और सिग्नल )

यह वर्चुअल फंक्शन तब कहा जाता है जब इस ऑब्जेक्ट में सिग्नल से कुछ जोड़ा गया हो।

यदि आप किसी विशिष्ट सिग्नल के साथ सिग्नल की तुलना करना चाहते हैं, तो आप QMetaMethod::fromSignal () का उपयोग इस प्रकार कर सकते हैं:

if (signal == QMetaMethod::fromSignal(&MyObject::valueChanged)) {
    // signal is valueChanged
}

चेतावनी: यह फ़ंक्शन मॉड्यूलरिटी के ऑब्जेक्ट-ओरिएंटेड सिद्धांत का उल्लंघन करता है। हालाँकि, यह उपयोगी हो सकता है जब आपको महंगे इनिशियलाइज़ेशन करने की आवश्यकता होती है, जब कोई सिग्नल से जुड़ा हो।

चेतावनी: यह फ़ंक्शन उस थ्रेड से कहा जाता है जो कनेक्शन को निष्पादित करता है, जो उस थ्रेड से एक अलग थ्रेड हो सकता है जिसमें यह ऑब्जेक्ट रहता है।

यह फ़ंक्शन Qt 5.0 में पेश किया गया था।

connect भी देखें () और disconnectNotify ()।

[virtual protected] शून्य QObject :: customEvent ( QEvent * घटना )

इस ईवेंट हैंडलर को कस्टम इवेंट प्राप्त करने के लिए एक उपवर्ग में पुन: कार्यान्वित किया जा सकता है। कस्टम ईवेंट उपयोगकर्ता-निर्धारित ईवेंट हैं, जो कम से कम QEvent::ChildAdded रूप में एक बड़े मान के साथ हैं: QEvent::ChildAdded आइटम QEvent::ChildAdded करें QEvent::ChildAdded , और आमतौर पर QEvent उपवर्ग है। ईवेंट पैरामीटर में इवेंट पास किया जाता है।

event () और QEvent भी देखें

[slot] शून्य QObject :: हटाएं ()

हटाने के लिए इस ऑब्जेक्ट को शेड्यूल करता है।

ईवेंट लूप पर नियंत्रण वापस आने पर ऑब्जेक्ट हटा दिया जाएगा। यदि इस फ़ंक्शन को कॉल करने पर इवेंट लूप नहीं चल रहा है (जैसे कि deleteLater () QCoreApplication::exec ()) से पहले किसी ऑब्जेक्ट पर कॉल किया जाता है, तो इवेंट लूप शुरू होने के बाद ऑब्जेक्ट हटा दिया जाएगा। यदि मुख्य ईवेंट लूप बंद होने के बाद डिलीटलेटर () को कॉल किया जाता है, तो ऑब्जेक्ट डिलीट नहीं होगा। क्यूटी 4.8 के बाद से, यदि डिलीट लैटर () उस ऑब्जेक्ट पर कॉल किया जाता है जो थ्रेड नहीं रहने वाले लूप के साथ थ्रेड में रहता है, तो थ्रेड खत्म होने पर ऑब्जेक्ट नष्ट हो जाएगा।

ध्यान दें कि एक नया ईवेंट लूप दर्ज करना और छोड़ना (जैसे, एक मोडल डायलॉग खोलकर) आस्थगित विलोपन नहीं करेगा; हटाए जाने वाले ऑब्जेक्ट के लिए, कंट्रोल को उस इवेंट लूप पर वापस लौटना चाहिए, जहां से डिलीट () को बुलाया गया था।

नोट: इस फ़ंक्शन को एक से अधिक बार कॉल करना सुरक्षित है; जब पहली आस्थगित विलोपन घटना को वितरित किया जाता है, तो ऑब्जेक्ट के लिए कोई भी लंबित इवेंट ईवेंट कतार से हटा दिया जाता है।

destroyed () और QPointer भी देखें

[signal] शून्य QObject :: नष्ट ( QObject * obj = nullptr)

ऑब्जेक्ट के नष्ट होने से ठीक पहले यह संकेत उत्सर्जित होता है, और अवरुद्ध नहीं किया जा सकता है।

इस संकेत के उत्सर्जित होने के तुरंत बाद सभी वस्तुओं के बच्चे नष्ट हो जाते हैं।

deleteLater () और QPointer भी देखें

[static] बूल QObject :: डिस्कनेक्ट (const QObject * प्रेषक , QObject चार * संकेत , QObject * रिसीवर , QObject चार * विधि )

ऑब्जेक्ट रिसीवर में विधि से ऑब्जेक्ट प्रेषक में सिग्नल को डिस्कनेक्ट करता है। यदि कनेक्शन सफलतापूर्वक टूट गया true तो लौटाता true ; अन्यथा false लौट आता false

सिग्नल-स्लॉट कनेक्शन को हटा दिया जाता है जब इसमें शामिल वस्तुओं को नष्ट कर दिया जाता है।

डिस्कनेक्ट () आमतौर पर तीन तरीकों से उपयोग किया जाता है, जैसा कि निम्नलिखित उदाहरण प्रदर्शित करते हैं।

  1. किसी वस्तु के संकेतों से जुड़ी हर चीज को डिस्कनेक्ट करें:
    disconnect(myObject, 0, 0, 0);

    गैर-स्थिर ओवरलोड फ़ंक्शन के बराबर

    myObject->disconnect();
  2. एक विशिष्ट सिग्नल से जुड़ी सभी चीजों को डिस्कनेक्ट करें:
    disconnect(myObject, SIGNAL(mySignal()), 0, 0);

    गैर-स्थिर ओवरलोड फ़ंक्शन के बराबर

    myObject->disconnect(SIGNAL(mySignal()));
  3. एक विशिष्ट रिसीवर को डिस्कनेक्ट करें:
    disconnect(myObject, 0, myReceiver, 0);

    गैर-स्थिर ओवरलोड फ़ंक्शन के बराबर

    myObject->disconnect(myReceiver);

0 का उपयोग वाइल्डकार्ड के रूप में किया जा सकता है, जिसका अर्थ है "कोई भी संकेत", "कोई प्राप्त वस्तु", या "प्राप्त वस्तु में कोई स्लॉट", क्रमशः।

प्रेषक कभी भी 0. नहीं हो सकता (आप एक कॉल में एक से अधिक ऑब्जेक्ट से संकेतों को डिस्कनेक्ट नहीं कर सकते।)

यदि संकेत 0 है, तो यह किसी भी सिग्नल से रिसीवर और विधि को डिस्कनेक्ट करता है। यदि नहीं, तो केवल निर्दिष्ट संकेत काट दिया गया है।

यदि रिसीवर 0 है, तो यह सिग्नल से जुड़ी किसी भी चीज़ को डिस्कनेक्ट करता है । यदि नहीं, तो रिसीवर के अलावा अन्य वस्तुओं में स्लॉट नहीं काटे जाते हैं।

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

नोट: यह फ़ंक्शन reentrant

connect भी देखें ()।

[static] बूल QObject :: डिस्कनेक्ट (const QObject * प्रेषक , QMetaMethod & सिग्नल , const QObject * रिसीवर , const QMetaMethod & विधि )

ऑब्जेक्ट रिसीवर में विधि से ऑब्जेक्ट प्रेषक में सिग्नल को डिस्कनेक्ट करता है। यदि कनेक्शन सफलतापूर्वक टूट गया true तो लौटाता true ; अन्यथा false लौट आता false

यह फ़ंक्शन disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) जैसी ही संभावनाएं प्रदान करता है disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) लेकिन सिग्नल और डिस्कनेक्ट होने की विधि का प्रतिनिधित्व करने के लिए QMetaMethod का उपयोग करता है।

इसके अतिरिक्त यह फ़ंक्शन देता है और यदि कोई सिग्नल और स्लॉट नहीं काटता है:

  1. संकेत प्रेषक वर्ग या उसके मूल वर्गों में से एक का सदस्य नहीं है।
  2. विधि रिसीवर वर्ग या इसके मूल वर्गों में से एक का सदस्य नहीं है।
  3. संकेत उदाहरण एक संकेत नहीं दर्शाता है।

QMetaMethod () का अर्थ "किसी भी संकेत" या "वस्तु प्राप्त करने में किसी भी स्लॉट" में वाइल्डकार्ड के रूप में किया जा सकता है। उसी तरह 0 का उपयोग "किसी भी प्राप्त वस्तु" अर्थ में रिसीवर के लिए किया जा सकता है । इस मामले में विधि QMetaMethod () भी होनी चाहिए। प्रेषक पैरामीटर कभी 0 नहीं होना चाहिए।

यह फ़ंक्शन Qt 4.8 में पेश किया गया था।

यह भी देखें disconnect (स्थिरांक QObject * प्रेषक, स्थिरांक चार * संकेत, स्थिरांक QObject * रिसीवर, स्थिरांक चार * विधि)।

बूल QObject :: डिस्कनेक्ट (const char * signal = nullptr, const QObject * रिसीवर = nullptr, const char * method = nullptr) const

यह फ़ंक्शन ओवरलोड को disconnect ()।

डिस्कनेक्ट संकेत से विधि के रिसीवर

सिग्नल-स्लॉट कनेक्शन को हटा दिया जाता है जब इसमें शामिल वस्तुओं को नष्ट कर दिया जाता है।

नोट: यह फ़ंक्शन reentrant

बूल QObject :: डिस्कनेक्ट (const QObject * रिसीवर , const char * पद्धति = nullptr)

यह फ़ंक्शन ओवरलोड को disconnect ()।

रिसीवर के विधि से इस ऑब्जेक्ट में सभी संकेतों को डिस्कनेक्ट करता है ।

सिग्नल-स्लॉट कनेक्शन को हटा दिया जाता है जब इसमें शामिल वस्तुओं को नष्ट कर दिया जाता है।

[static] बूल QObject :: डिस्कनेक्ट (const QMetaObject :: QMetaObject::Connection और कनेक्शन )

एक कनेक्शन डिस्कनेक्ट करें।

यदि कनेक्शन अमान्य है या पहले ही डिस्कनेक्ट हो गया है, तो कुछ भी न करें और गलत न लौटें।

connect भी देखें ()।

[static] बूल QObject :: डिस्कनेक्ट (const QObject * प्रेषक , PointerToMemberFunction संकेत , const QObject * रिसीवर , PointerToMemberFunction विधि )

यह फ़ंक्शन अधिभार () को ओवरलोड करता है।

ऑब्जेक्ट रिसीवर में विधि से ऑब्जेक्ट प्रेषक में सिग्नल को डिस्कनेक्ट करता है । यदि कनेक्शन सफलतापूर्वक टूट गया है तो लौटाता है ; true अन्यथा false लौट आता false

सिग्नल-स्लॉट कनेक्शन को हटा दिया जाता है जब इसमें शामिल वस्तुओं को नष्ट कर दिया जाता है।

disconnect () आमतौर पर तीन तरीकों से उपयोग किया जाता है, जैसा कि निम्नलिखित उदाहरण प्रदर्शित करते हैं।

  1. किसी वस्तु के संकेतों से जुड़ी हर चीज को डिस्कनेक्ट करें:
    disconnect(myObject, 0, 0, 0);
  2. एक विशिष्ट सिग्नल से जुड़ी सभी चीजों को डिस्कनेक्ट करें:
    disconnect(myObject, &MyObject::mySignal(), 0, 0);
  3. एक विशिष्ट रिसीवर को डिस्कनेक्ट करें:
    disconnect(myObject, 0, myReceiver, 0);
  4. एक विशिष्ट सिग्नल से एक कनेक्शन को एक विशिष्ट स्लॉट में डिस्कनेक्ट करें:
    QObject::disconnect(lineEdit, &QLineEdit::textChanged,
                     label,  &QLabel::setText);

0 का उपयोग वाइल्डकार्ड के रूप में किया जा सकता है, जिसका अर्थ है "कोई भी संकेत", "कोई प्राप्त वस्तु", या "प्राप्त वस्तु में कोई स्लॉट", क्रमशः।

इस कभी नहीं हो सकता है 0. (आप एक कॉल में एक से अधिक वस्तु से संकेत डिस्कनेक्ट नहीं कर सकते हैं।)

यदि संकेत 0 है, तो यह किसी भी सिग्नल से रिसीवर और विधि को डिस्कनेक्ट करता है। यदि नहीं, तो केवल निर्दिष्ट संकेत काट दिया गया है।

यदि रिसीवर 0 है, तो यह सिग्नल से जुड़ी किसी भी चीज़ को डिस्कनेक्ट करता है । यदि नहीं, तो रिसीवर के अलावा अन्य वस्तुओं में स्लॉट नहीं काटे जाते हैं।

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

नोट: इस ओवरलोड का उपयोग फंक्शनलर्स या लैम्ब्डा एक्सप्रेशंस से जुड़े सिग्नल को डाइकनेक्ट करने के लिए संभव नहीं है। ऐसा इसलिए है क्योंकि उनकी तुलना करना संभव नहीं है। इसके बजाय, QMetaObject::Connection वाले अधिभार का उपयोग करें QMetaObject::Connection

नोट: यह फ़ंक्शन reentrant

connect भी देखें ()।

[virtual protected] शून्य QObject :: डिस्कनेक्ट करें (const QMetaMethod और सिग्नल )

यह वर्चुअल फ़ंक्शन तब कहा जाता है जब इस ऑब्जेक्ट में सिग्नल से कुछ काट दिया गया हो ।

एक विशिष्ट सिग्नल के साथ सिग्नल की तुलना कैसे करें, इसके उदाहरण के लिए connectNotify () देखें ।

यदि इस ऑब्जेक्ट से सभी सिग्नल काट दिए गए थे (उदाहरण के लिए, disconnect करने के लिए सिग्नल तर्क 0 था), डिस्कनेक्टनेक्ट () केवल एक बार कॉल किया जाता है, और सिग्नल एक अमान्य QMetaMethod ( QMetaMethod::isValid () रिटर्न false ) होगा।

चेतावनी: यह फ़ंक्शन मॉड्यूलरिटी के ऑब्जेक्ट-ओरिएंटेड सिद्धांत का उल्लंघन करता है। हालांकि, यह महंगे संसाधनों तक पहुंच के अनुकूलन के लिए उपयोगी हो सकता है।

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

यह फ़ंक्शन Qt 5.0 में पेश किया गया था।

disconnect () और connectNotify () भी देखें

शून्य QObject :: dipObjectInfo () कास्ट

डीबग आउटपुट के लिए इस ऑब्जेक्ट के लिए संकेत कनेक्शन, आदि के बारे में जानकारी।

नोट: Qt 5.9 से पहले, यह फ़ंक्शन कांस्टेबल नहीं था।

dumpObjectTree () भी देखें

शून्य QObject :: डंपऑब्जेक्टट्री () कास्ट

डिबग आउटपुट में बच्चों के एक पेड़ को डुबोता है।

नोट: Qt 5.9 से पहले, यह फ़ंक्शन कांस्टेबल नहीं था।

dumpObjectInfo () भी देखें

QList < QByteArray > QObject :: DynamicPropertyNames () const

सभी गुणों के नाम लौटाता है जो गतिशील रूप से setProperty () का उपयोग करके ऑब्जेक्ट में जोड़ा गया था ।

यह फ़ंक्शन Qt 4.2 में पेश किया गया था।

[virtual] बूल QObject :: इवेंट ( QEvent * e )

यह वर्चुअल फ़ंक्शन ईवेंट को ऑब्जेक्ट के लिए प्राप्त करता है और यदि इवेंट में पहचाना और संसाधित किया गया था , तो उसे वापस लौटना चाहिए ।

किसी वस्तु के व्यवहार को अनुकूलित करने के लिए घटना () फ़ंक्शन को फिर से लागू किया जा सकता है।

सुनिश्चित करें कि आप उन सभी घटनाओं के लिए मूल इवेंट क्लास कार्यान्वयन को कॉल करते हैं जिन्हें आपने नहीं हैंडल किया था।

उदाहरण:

class MyClass : public QWidget
{
    Q_OBJECT

public:
    MyClass(QWidget *parent = 0);
    ~MyClass();

    bool event(QEvent* ev)
    {
        if (ev->type() == QEvent::PolishRequest) {
            // overwrite handling of PolishRequest if any
            doThings();
            return true;
        } else  if (ev->type() == QEvent::Show) {
            // complement handling of Show if any
            doThings2();
            QWidget::event(ev);
            return true;
        }
        // Make sure the rest of events are handled
        return QWidget::event(ev);
    }
};

यह भी देखें installEventFilter (), timerEvent (), QCoreApplication::sendEvent (), और QCoreApplication::postEvent ()।

[virtual] बूल QObject :: eventFilter ( QObject * देखा , QEvent * घटना )

इस वस्तु को अगर देखे गए ऑब्जेक्ट के लिए एक इवेंट फिल्टर के रूप में स्थापित किया गया है, तो फिल्टर घटनाओं ।

इस फ़ंक्शन के आपके क्रियान्वयन में, यदि आप ईवेंट को फ़िल्टर करना चाहते हैं, अर्थात इसे आगे संभालना बंद कर दें, तो वापस लौटें; अन्यथा झूठे लौटते हैं।

उदाहरण:

class MainWindow : public QMainWindow
{
public:
    MainWindow();

protected:
    bool eventFilter(QObject *obj, QEvent *ev);

private:
    QTextEdit *textEdit;
};

MainWindow::MainWindow()
{
    textEdit = new QTextEdit;
    setCentralWidget(textEdit);

    textEdit->installEventFilter(this);
}

bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
    if (obj == textEdit) {
        if (event->type() == QEvent::KeyPress) {
            QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
            qDebug() << "Ate key press" << keyEvent->key();
            return true;
        } else {
            return false;
        }
    } else {
        // pass the event on to the parent class
        return QMainWindow::eventFilter(obj, event);
    }
}

ऊपर दिए गए उदाहरण में ध्यान दें कि अनहेल्ड किए गए ईवेंट बेस क्लास के ईवेंटफिल्टर () फ़ंक्शन को पास किए जाते हैं, क्योंकि बेस क्लास ने अपने स्वयं के आंतरिक उद्देश्यों के लिए ईवेंटफिल्टर () को फिर से लागू किया हो सकता है।

चेतावनी: यदि आप इस फ़ंक्शन में रिसीवर ऑब्जेक्ट को हटाते हैं, तो सही लौटना सुनिश्चित करें। अन्यथा, Qt ईवेंट को हटाए गए ऑब्जेक्ट पर अग्रेषित करेगा और प्रोग्राम क्रैश हो सकता है।

installEventFilter () भी देखें

टी QObject :: findChild (स्थिरांक QString और नाम = QString (), क्यूटी :: FindChildOptions विकल्प = क्यूटी :: FindChildrenRecursively) स्थिरांक

इस वस्तु के बच्चे को लौटाता है जिसे टाइप T में डाला जा सकता है और जिसे ऐसी कोई वस्तु नहीं है, या नाम कहा जाता है। नाम तर्क को स्वीकार करने से सभी ऑब्जेक्ट नामों का मिलान हो जाता है। खोज को पुनरावर्ती रूप से निष्पादित किया जाता है, जब तक कि विकल्प FindDirectChildrenOnly विकल्प निर्दिष्ट नहीं करता है।

यदि खोज से मेल खाते एक से अधिक बच्चे हैं, तो सबसे प्रत्यक्ष पूर्वज वापस आ जाता है। यदि कई प्रत्यक्ष पूर्वज हैं, तो यह अपरिभाषित है, जिसे वापस कर दिया जाएगा। उस स्थिति में, findChildren () का उपयोग किया जाना चाहिए।

यह उदाहरण नाम के एक बच्चे QPushButton को देता है , भले ही बटन माता-पिता का प्रत्यक्ष बच्चा न हो: parentWidget "button1"

QPushButton *button = parentWidget->findChild<QPushButton *>("button1");

यह उदाहरण एक QListWidget बच्चे को देता है parentWidget :

QListWidget *list = parentWidget->findChild<QListWidget *>();

यह उदाहरण (उसके प्रत्यक्ष माता-पिता) के एक बच्चे QPushButton का parentWidget नाम देता है "button1" :

QPushButton *button = parentWidget->findChild<QPushButton *>("button1", Qt::FindDirectChildrenOnly);

यह उदाहरण , उसके प्रत्यक्ष माता-पिता QListWidget का एक बच्चा देता है parentWidget :

QListWidget *list = parentWidget->findChild<QListWidget *>(QString(), Qt::FindDirectChildrenOnly);

findChildren () भी देखें

QList < टी > QObject :: findChildren (स्थिरांक QString और नाम = QString (), क्यूटी :: FindChildOptions विकल्प = क्यूटी :: FindChildrenRecursively) स्थिरांक

इस ऑब्जेक्ट के सभी बच्चों को दिए गए नाम के साथ लौटाता है जिसे टी टाइप करने के लिए कास्ट किया जा सकता है, या कोई खाली सूची नहीं है अगर ऐसी कोई वस्तु नहीं है। नाम तर्क को स्वीकार करने से सभी ऑब्जेक्ट नामों का मिलान हो जाता है। खोज को पुनरावर्ती रूप से निष्पादित किया जाता है, जब तक कि विकल्प FindDirectChildrenOnly विकल्प निर्दिष्ट नहीं करता है।

निम्नलिखित उदाहरण से पता चलता है कि QWidget निर्दिष्ट parentWidget नाम के बच्चे की सूची कैसे प्राप्त करें widgetname :

QList<QWidget *> widgets = parentWidget.findChildren<QWidget *>("widgetname");

यह उदाहरण उन सभी को लौटाता है QPushButton जो बच्चे हैं parentWidget :

QList<QPushButton *> allPButtons = parentWidget.findChildren<QPushButton *>();

यह उदाहरण उन सभी को लौटाता है QPushButton जो तत्काल बच्चे हैं parentWidget :

QList<QPushButton *> childButtons = parentWidget.findChildren<QPushButton *>(QString(), Qt::FindDirectChildrenOnly);

findChild () भी देखें

QList < T > QObject :: findChildren (const QRegExp & regExp , Qt :: FindChildOptions options = Qt :: FindChildrenRecursively) const

इस फ़ंक्शन को अधिभार मिल जाता है findChildren ()।

इस ऑब्जेक्ट के बच्चे लौटाते हैं जिन्हें T टाइप किया जा सकता है और जिनके नाम रेगुलर एक्सप्रेशन regExp , या कोई खाली सूची से मेल खाते हैं , अगर ऐसी कोई ऑब्जेक्ट नहीं हैं। खोज को पुनरावर्ती रूप से निष्पादित किया जाता है, जब तक कि विकल्प FindDirectChildrenOnly विकल्प निर्दिष्ट नहीं करता है।

QList < T > QObject :: findChildren (const QRegularExpression & re , Qt :: FindChildOptions options = Qt :: FindChildrenRecursively) const

इस फ़ंक्शन को अधिभार मिल जाता है findChildren ()।

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

यह फ़ंक्शन Qt 5.0 में पेश किया गया था।

बूल QObject :: विरासत में मिला (const char * className ) const

रिटर्न true अगर इस वस्तु एक वर्ग है कि विरासत में का एक उदाहरण है className या एक QObject उपवर्ग है कि विरासत में className ; अन्यथा false लौट आता false

एक वर्ग को विरासत में ही माना जाता है।

उदाहरण:

QTimer *timer = new QTimer;         // QTimer inherits QObject
timer->inherits("QTimer");          // returns true
timer->inherits("QObject");         // returns true
timer->inherits("QAbstractButton"); // returns false

// QVBoxLayout inherits QObject and QLayoutItem
QVBoxLayout *layout = new QVBoxLayout;
layout->inherits("QObject");        // returns true
layout->inherits("QLayoutItem");    // returns true (even though QLayoutItem is not a QObject)

यदि आपको यह निर्धारित करने की आवश्यकता है कि क्या ऑब्जेक्ट इसे कास्टिंग के उद्देश्य के लिए एक विशेष वर्ग का उदाहरण है, इसके बजाय qobject_cast <टाइप *> (ऑब्जेक्ट) का उपयोग करने पर विचार करें ।

metaObject () और qobject_cast () भी देखें

शून्य QObject :: installEventFilter ( QObject * filterObj )

इस ऑब्जेक्ट पर एक ईवेंट फ़िल्टर फ़िल्टर स्थापित करें। उदाहरण के लिए:

monitoredObj->installEventFilter(filterObj);

एक ईवेंट फ़िल्टर एक ऑब्जेक्ट है, जो इस ईवेंट में भेजे जाने वाले सभी ईवेंट प्राप्त करता है। फ़िल्टर या तो घटना को रोक सकता है या उसे इस ऑब्जेक्ट पर अग्रेषित कर सकता है। इवेंट फ़िल्टर FilterObj अपने eventFilter () फ़ंक्शन के माध्यम से ईवेंट प्राप्त करता है। eventFilter () फ़ंक्शन सच लौटना चाहिए अगर घटना फिल्टर किया जाना चाहिए, (यानी बंद कर दिया); अन्यथा यह गलत होना चाहिए।

यदि किसी एकल ऑब्जेक्ट पर कई ईवेंट फ़िल्टर स्थापित किए जाते हैं, तो अंतिम बार स्थापित किया गया फ़िल्टर पहले सक्रिय हो जाता है।

यहां एक KeyPressEater वर्ग है जो अपनी निगरानी की गई वस्तुओं के प्रमुख प्रेस को खाता है:

class KeyPressEater : public QObject
{
    Q_OBJECT
    ...

protected:
    bool eventFilter(QObject *obj, QEvent *event);
};

bool KeyPressEater::eventFilter(QObject *obj, QEvent *event)
{
    if (event->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        qDebug("Ate key press %d", keyEvent->key());
        return true;
    } else {
        // standard event processing
        return QObject::eventFilter(obj, event);
    }
}

और यहां दो विजेट्स पर इसे कैसे स्थापित किया जाए:

KeyPressEater *keyPressEater = new KeyPressEater(this);
QPushButton *pushButton = new QPushButton(this);
QListView *listView = new QListView(this);

pushButton->installEventFilter(keyPressEater);
listView->installEventFilter(keyPressEater);

QShortcut वर्ग, उदाहरण के लिए, शॉर्टकट कुंजी प्रेस अवरोधन के लिए इस तकनीक का उपयोग करता है।

चेतावनी: यदि आप अपने eventFilter () फ़ंक्शन में रिसीवर ऑब्जेक्ट को eventFilter , तो वापस लौटना सुनिश्चित करें। यदि आप गलत लौटते हैं, तो Qt ईवेंट को हटाए गए ऑब्जेक्ट पर भेजता है और प्रोग्राम क्रैश हो जाएगा।

ध्यान दें कि फ़िल्टरिंग ऑब्जेक्ट इस ऑब्जेक्ट के समान थ्रेड में होना चाहिए। अगर FilterObj एक अलग थ्रेड में है, तो यह फ़ंक्शन कुछ भी नहीं करता है। यदि इस फ़ंक्शन को कॉल करने के बाद या तो filterObj या इस ऑब्जेक्ट को एक अलग थ्रेड में ले जाया जाता है, तो इवेंट फ़िल्टर तब तक नहीं बुलाया जाएगा जब तक कि दोनों ऑब्जेक्ट्स में एक ही थ्रेड एफिनिटी फिर से हो (यह निकाला नहीं गया)।

इन्हें भी देखें removeEventFilter (), eventFilter (), और event ()।

[protected] बूल QObject :: isSignalConnected (const QMetaMethod & सिग्नल ) const

रिटर्न true अगर संकेत कम से कम एक रिसीवर से जुड़ा है, अन्यथा रिटर्न false

सिग्नल इस ऑब्जेक्ट का सिग्नल सदस्य होना चाहिए, अन्यथा व्यवहार अपरिभाषित है।

static const QMetaMethod valueChangedSignal = QMetaMethod::fromSignal(&MyObject::valueChanged);
if (isSignalConnected(valueChangedSignal)) {
    QByteArray data;
    data = get_the_value();       // expensive operation
    emit valueChanged(data);
}

जैसा कि ऊपर कोड स्निपेट दिखाता है, आप इस फ़ंक्शन का उपयोग उस सिग्नल को छोड़ने से बचने के लिए कर सकते हैं जिसे कोई भी नहीं सुनता है।

चेतावनी: यह फ़ंक्शन मॉड्यूलरिटी के ऑब्जेक्ट-ओरिएंटेड सिद्धांत का उल्लंघन करता है। हालाँकि, यह उपयोगी हो सकता है जब आपको महंगे इनिशियलाइज़ेशन करने की आवश्यकता होती है केवल तभी जब कोई सिग्नल से जुड़ा हो।

यह फ़ंक्शन Qt 5.0 में पेश किया गया था।

बूल QObject :: isWidgetType () const

रिटर्न true अगर वस्तु एक विजेट है; अन्यथा false लौट आता false

इस फ़ंक्शन को कॉल करना कॉल करने के बराबर है inherits("QWidget") , सिवाय इसके कि यह बहुत तेज़ है।

बूल QObject :: isWindowType () const

true यदि वस्तु एक खिड़की है तो वापस लौटती है; अन्यथा false लौट आता false

इस फ़ंक्शन को कॉल करना कॉल करने के बराबर है inherits("QWindow") , सिवाय इसके कि यह बहुत तेज़ है।

शून्य QObject :: KillTimer ( int id )

टाइमर को टाइमर पहचानकर्ता, आईडी के साथ मारता है ।

टाइमर पहचानकर्ता startTimer () द्वारा लौटाया जाता है जब टाइमर घटना शुरू होती है।

यह भी देखें timerEvent () और startTimer ()।

[virtual] स्थिरांक QMetaObject * QObject :: metaObject () स्थिरांक

इस ऑब्जेक्ट के मेटा-ऑब्जेक्ट के लिए एक पॉइंटर लौटाता है।

एक मेटा-ऑब्जेक्ट में एक वर्ग के बारे में जानकारी होती है जो QObject , जैसे वर्ग का नाम, QObject नाम, गुण, सिग्नल और स्लॉट विरासत में QObject । प्रत्येक QObject उपवर्ग जिसमें Q_OBJECT मैक्रो होता है, एक मेटा-ऑब्जेक्ट होगा।

मेटा-ऑब्जेक्ट जानकारी सिग्नल / स्लॉट कनेक्शन तंत्र और संपत्ति प्रणाली द्वारा आवश्यक है। inherits () फ़ंक्शन भी मेटा-वस्तु का उपयोग करता है।

यदि आपके पास वास्तविक वस्तु उदाहरण के लिए कोई संकेतक नहीं है, लेकिन फिर भी एक वर्ग के मेटा-ऑब्जेक्ट तक पहुंचना चाहते हैं, तो आप staticMetaObject उपयोग कर सकते हैं ।

उदाहरण:

QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns "QPushButton"

QPushButton::staticMetaObject.className();  // returns "QPushButton"

staticMetaObject भी देखें

शून्य QObject :: moveToThread ( QThread * targetThread )

इस वस्तु और इसके बच्चों के लिए धागा संबंध को बदलता है। यदि माता-पिता के पास यह वस्तु नहीं है, तो इसे स्थानांतरित नहीं किया जा सकता है। ईवेंट प्रसंस्करण लक्ष्य में जारी रहेगा ।

किसी ऑब्जेक्ट को मुख्य थ्रेड में ले जाने के लिए, QApplication :: उदाहरण () को वर्तमान एप्लिकेशन के लिए एक पॉइंटर को प्राप्त करने के लिए उपयोग करें, और फिर उस एप्लिकेशन को पुनः प्राप्त करने के लिए QApplication :: thread () का उपयोग करें जिसमें एप्लिकेशन रहता है। उदाहरण के लिए:

myObject->moveToThread(QApplication::instance()->thread());

यदि targetThread शून्य है, तो इस ऑब्जेक्ट और उसके बच्चों के लिए सभी इवेंट प्रोसेसिंग बंद हो जाती है।

ध्यान दें कि ऑब्जेक्ट के लिए सभी सक्रिय टाइमर रीसेट हो जाएंगे। टाइमर पहले मौजूदा धागा में बंद कर दिया और पुन: प्रारंभ (समान अंतराल के साथ) में कर रहे हैं targetThread । परिणामस्वरूप, थ्रेड्स के बीच किसी ऑब्जेक्ट को लगातार स्थानांतरित करना टाइमर की घटनाओं को अनिश्चित काल के लिए स्थगित कर सकता है।

एक QEvent::ChildAdded इवेंट को QEvent::ChildAdded को बदलने से ठीक पहले इस ऑब्जेक्ट पर भेजा जाता है। आप किसी भी विशेष प्रसंस्करण को करने के लिए इस घटना को संभाल सकते हैं। ध्यान दें कि इस ऑब्जेक्ट पर पोस्ट की गई कोई भी नई ईवेंट टारगेट में हैंडल की जाएगी ।

चेतावनी: इस समारोह है नहीं धागा सुरक्षित; वर्तमान धागा वर्तमान धागे की आत्मीयता के समान होना चाहिए। दूसरे शब्दों में, यह फ़ंक्शन केवल एक ऑब्जेक्ट को वर्तमान थ्रेड से दूसरे थ्रेड में "पुश" कर सकता है, यह किसी ऑब्जेक्ट को किसी भी मनमाने थ्रेड से वर्तमान थ्रेड पर "खींच" नहीं सकता है।

thread भी देखें ()।

[signal] शून्य QObject :: objectNameChanged (स्थिरांक QString और objectname )

ऑब्जेक्ट का नाम बदलने के बाद यह सिग्नल उत्सर्जित होता है। नया ऑब्जेक्ट नाम objectName के रूप में पास किया गया है ।

नोट: यह एक निजी संकेत है। इसका उपयोग सिग्नल कनेक्शन में किया जा सकता है लेकिन उपयोगकर्ता द्वारा उत्सर्जित नहीं किया जा सकता है।

नोट: संपत्ति objectName लिए नोटिफ़ायर सिग्नल ।

objectName भी देखें

QObject * QObject :: माता-पिता () कांस्टेबल

मूल वस्तु के लिए एक सूचक लौटाता है।

setParent () और children () को भी देखें

QVariant QObject :: संपत्ति (const char * name ) कास्ट

ऑब्जेक्ट के नाम गुण का मान लौटाता है ।

यदि ऐसी कोई संपत्ति मौजूद नहीं है, तो लौटा हुआ संस्करण अमान्य है।

सभी उपलब्ध संपत्तियों के बारे में जानकारी metaObject () और dynamicPropertyNames () के माध्यम से दी metaObject

यह भी देखें setProperty (), QVariant::isValid (), metaObject (), और dynamicPropertyNames ()।

[protected] int QObject :: रिसीवर ( कास्ट चार * सिग्नल ) कास्ट

सिग्नल से जुड़े रिसीवर्स की संख्या लौटाता है ।

चूंकि दोनों स्लॉट और सिग्नल सिग्नल के लिए रिसीवर के रूप में उपयोग किए जा सकते हैं, और एक ही कनेक्शन को कई बार बनाया जा सकता है, रिसीवर की संख्या इस सिग्नल से बने कनेक्शन की संख्या के समान है।

इस फ़ंक्शन को कॉल करते समय, आप SIGNAL() एक विशिष्ट सिग्नल पास करने के लिए मैक्रो का उपयोग कर सकते हैं :

if (receivers(SIGNAL(valueChanged(QByteArray))) > 0) {
    QByteArray data;
    get_the_value(&data);       // expensive operation
    emit valueChanged(data);
}

चेतावनी: यह फ़ंक्शन मॉड्यूलरिटी के ऑब्जेक्ट-ओरिएंटेड सिद्धांत का उल्लंघन करता है। हालाँकि, यह उपयोगी हो सकता है जब आपको महंगे इनिशियलाइज़ेशन करने की आवश्यकता होती है केवल तभी जब कोई सिग्नल से जुड़ा हो।

यह भी देखें isSignalConnected ()

शून्य QObject :: removeEventFilter ( QObject * obj )

इस ऑब्जेक्ट से इवेंट फ़िल्टर ऑब्जेक्ट obj हटाता है । अनुरोध को अनदेखा किया जाता है यदि ऐसा कोई ईवेंट फ़िल्टर स्थापित नहीं किया गया है।

इस ऑब्जेक्ट के लिए सभी ईवेंट फ़िल्टर स्वचालित रूप से हटा दिए जाते हैं जब यह ऑब्जेक्ट नष्ट हो जाता है।

ईवेंट फ़िल्टर सक्रियण के दौरान ( eventFilter () फ़ंक्शन से भी) इवेंट फ़िल्टर को निकालना हमेशा सुरक्षित होता है ।

यह भी देखें installEventFilter (), eventFilter (), और event ()।

[protected] QObject * QObject :: प्रेषक () कांस्टेबल

संकेत भेजने वाले ऑब्जेक्ट पर एक पॉइंटर लौटाता है, अगर सिग्नल द्वारा सक्रिय स्लॉट में कहा जाता है; अन्यथा यह 0. लौटाता है। सूचक केवल उस स्लॉट के निष्पादन के दौरान मान्य है जो इस फ़ंक्शन को इस ऑब्जेक्ट के थ्रेड संदर्भ से कहता है।

इस फ़ंक्शन द्वारा लौटाए गए सूचक अमान्य हो जाते हैं यदि प्रेषक नष्ट हो जाता है, या यदि प्रेषक के सिग्नल से स्लॉट काट दिया जाता है।

चेतावनी: यह फ़ंक्शन मॉड्यूलरिटी के ऑब्जेक्ट-ओरिएंटेड सिद्धांत का उल्लंघन करता है। हालाँकि, प्रेषक तक पहुँच उपयोगी हो सकती है जब कई सिग्नल एक ही स्लॉट से जुड़े हों।

चेतावनी: जैसा कि ऊपर उल्लेख किया गया है, इस फ़ंक्शन का रिटर्न मान मान्य नहीं है जब स्लॉट को Qt :: DirectConnection के माध्यम से इस ऑब्जेक्ट के थ्रेड से अलग कहा जाता है । इस प्रकार के परिदृश्य में इस फ़ंक्शन का उपयोग न करें।

senderSignalIndex () भी देखें

[protected] int QObject :: प्रेषक SignalIndex () const

वर्तमान में निष्पादित स्लॉट कहे जाने वाले सिग्नल के मेटा-विधि इंडेक्स को लौटाता है, जो sender () द्वारा लौटाए गए वर्ग का सदस्य है । यदि किसी सिग्नल के द्वारा सक्रिय किए गए स्लॉट के बाहर बुलाया जाता है, तो -1 लौटा दिया जाता है।

डिफ़ॉल्ट मापदंडों के साथ संकेतों के लिए, यह फ़ंक्शन हमेशा सभी मापदंडों के साथ सूचकांक लौटाएगा, जिसकी परवाह connect () के साथ किया गया था । उदाहरण के लिए, सिग्नल destroyed(QObject *obj = 0) में दो अलग-अलग इंडेक्स होंगे (पैरामीटर के साथ और बिना), लेकिन यह फ़ंक्शन हमेशा पैरामीटर के साथ इंडेक्स लौटाएगा। विभिन्न मापदंडों के साथ संकेतों को ओवरलोड करते समय यह लागू नहीं होता है।

चेतावनी: यह फ़ंक्शन मॉड्यूलरिटी के ऑब्जेक्ट-ओरिएंटेड सिद्धांत का उल्लंघन करता है। हालांकि, सिग्नल इंडेक्स तक पहुंच तब उपयोगी हो सकती है जब कई सिग्नल एक ही स्लॉट से जुड़े हों।

चेतावनी: इस फ़ंक्शन का रिटर्न मान मान्य नहीं है जब स्लॉट को Qt :: DirectConnection के माध्यम से इस ऑब्जेक्ट के थ्रेड से अलग कहा जाता है । इस प्रकार के परिदृश्य में इस फ़ंक्शन का उपयोग न करें।

यह फ़ंक्शन Qt 4.8 में पेश किया गया था।

यह भी देखें sender (), QMetaObject::indexOfSignal (), और QMetaObject::method ()।

शून्य QObject :: setParent ( QObject * माता-पिता )

ऑब्जेक्ट को पैरेंट का बच्चा बनाता है ।

parent () और children () भी देखें

bool QObject :: setProperty (स्थिरांक चार * नाम , स्थिरांक QVariant और मूल्य )

मान के लिए ऑब्जेक्ट के नाम गुण का मान सेट करता है ।

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

सभी उपलब्ध संपत्तियों के बारे में जानकारी metaObject () और dynamicPropertyNames () के माध्यम से दी metaObject

property () का उपयोग करके डायनामिक गुणों को फिर से QVariant किया जा सकता है और संपत्ति के मूल्य को अमान्य QVariant सेट करके हटाया जा सकता है । डायनेमिक प्रॉपर्टी का मूल्य बदलने से QDynamicPropertyChangeEvent को ऑब्जेक्ट में भेजा जाता है।

नोट: "_q_" से शुरू होने वाले गतिशील गुण आंतरिक उद्देश्यों के लिए आरक्षित हैं।

यह भी देखें property (), metaObject (), dynamicPropertyNames (), और QMetaProperty::write ()।

बूल QObject :: signalBlocked () const

रिटर्न true अगर संकेतों ब्लॉक किए गए हैं; अन्यथा false लौट आता false

डिफ़ॉल्ट रूप से सिग्नल अवरुद्ध नहीं होते हैं।

blockSignals () और QSignalBlocker भी देखें

पूर्णांक QObject :: startTimer ( पूर्णांक अंतराल , क्यूटी :: TimerType timerType = क्यूटी :: CoarseTimer)

एक टाइमर शुरू करता है और एक टाइमर पहचानकर्ता लौटाता है, या यदि वह टाइमर शुरू नहीं कर पाता तो शून्य लौटता है।

एक टाइमर घटना हर अंतराल मिलीसेकंड तक घटित होगी जब तक कि killTimer () नहीं कहा जाता है। यदि अंतराल 0 है, तो टाइमर घटना हर बार एक बार होती है जब प्रक्रिया के लिए अधिक विंडो सिस्टम इवेंट नहीं होते हैं।

वर्चुअल timerEvent () फ़ंक्शन को टाइमर इवेंट होने पर QTimerEvent इवेंट पैरामीटर क्लास के साथ कहा जाता है। टाइमर फ़ंक्शन प्राप्त करने के लिए इस फ़ंक्शन को पुन: लागू करें।

यदि कई टाइमर चल रहे हैं, तो यह QTimerEvent::timerId लिए कि टाइमर किस टाइमर को सक्रिय किया गया था , QTimerEvent::timerId () का उपयोग किया जा सकता है।

उदाहरण:

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject *parent = 0);

protected:
    void timerEvent(QTimerEvent *event);
};

MyObject::MyObject(QObject *parent)
    : QObject(parent)
{
    startTimer(50);     // 50-millisecond timer
    startTimer(1000);   // 1-second timer
    startTimer(60000);  // 1-minute timer

    using namespace std::chrono;
    startTimer(milliseconds(50));
    startTimer(seconds(1));
    startTimer(minutes(1));

    // since C++14 we can use std::chrono::duration literals, e.g.:
    startTimer(100ms);
    startTimer(5s);
    startTimer(2min);
    startTimer(1h);
}

void MyObject::timerEvent(QTimerEvent *event)
{
    qDebug() << "Timer ID:" << event->timerId();
}

ध्यान दें कि QTimer की सटीकता अंतर्निहित ऑपरेटिंग सिस्टम और हार्डवेयर पर निर्भर करती है। TimerType तर्क आप टाइमर की सटीकता अनुकूलित करने के लिए अनुमति देता है। विभिन्न टाइमर प्रकारों की जानकारी के लिए Qt::TimerType देखें। अधिकांश प्लेटफ़ॉर्म 20 मिलीसेकंड की सटीकता का समर्थन करते हैं; कुछ और प्रदान करते हैं। यदि Qt टाइमर घटनाओं की अनुरोधित संख्या को वितरित करने में असमर्थ है, तो यह चुपचाप कुछ त्याग देगा।

QTimer वर्ग सिंगल-शॉट टाइमर और घड़ी संकेतों के बजाय घटनाओं के साथ एक उच्च स्तरीय प्रोग्रामिंग इंटरफेस प्रदान करता है। वहाँ भी एक है QBasicTimer वर्ग की तुलना में अधिक हल्के है कि QTimer और सीधे टाइमर आईडी का उपयोग कम से कम अनाड़ी।

timerEvent भी देखें (), killTimer (), और QTimer::singleShot ()।

पूर्णांक QObject :: startTimer ( std :: chrono :: मिलीसेकंड समय , क्यूटी :: TimerType timerType = क्यूटी :: CoarseTimer)

यह एक अतिभारित फंक्शन है।

एक टाइमर शुरू करता है और एक टाइमर पहचानकर्ता लौटाता है, या यदि वह टाइमर शुरू नहीं कर पाता तो शून्य लौटता है।

जब तक कि killTimer () कहा जाता है तब तक हर बार एक अंतराल घटना killTimer । यदि समय के बराबर है std::chrono::duration::zero() , तो टाइमर घटना हर बार एक बार होती है जब प्रक्रिया के लिए अधिक विंडो सिस्टम इवेंट नहीं होते हैं।

वर्चुअल timerEvent () फ़ंक्शन को टाइमर इवेंट होने पर QTimerEvent इवेंट पैरामीटर क्लास के साथ कहा जाता है। टाइमर फ़ंक्शन प्राप्त करने के लिए इस फ़ंक्शन को पुन: लागू करें।

यदि कई टाइमर चल रहे हैं, तो यह QTimerEvent::timerId लिए कि टाइमर किस टाइमर को सक्रिय किया गया था , QTimerEvent::timerId () का उपयोग किया जा सकता है।

उदाहरण:

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject *parent = 0);

protected:
    void timerEvent(QTimerEvent *event);
};

MyObject::MyObject(QObject *parent)
    : QObject(parent)
{
    startTimer(50);     // 50-millisecond timer
    startTimer(1000);   // 1-second timer
    startTimer(60000);  // 1-minute timer

    using namespace std::chrono;
    startTimer(milliseconds(50));
    startTimer(seconds(1));
    startTimer(minutes(1));

    // since C++14 we can use std::chrono::duration literals, e.g.:
    startTimer(100ms);
    startTimer(5s);
    startTimer(2min);
    startTimer(1h);
}

void MyObject::timerEvent(QTimerEvent *event)
{
    qDebug() << "Timer ID:" << event->timerId();
}

ध्यान दें कि QTimer की सटीकता अंतर्निहित ऑपरेटिंग सिस्टम और हार्डवेयर पर निर्भर करती है। TimerType तर्क आप टाइमर की सटीकता अनुकूलित करने के लिए अनुमति देता है। विभिन्न टाइमर प्रकारों की जानकारी के लिए Qt::TimerType देखें। अधिकांश प्लेटफ़ॉर्म 20 मिलीसेकंड की सटीकता का समर्थन करते हैं; कुछ और प्रदान करते हैं। यदि Qt टाइमर घटनाओं की अनुरोधित संख्या को वितरित करने में असमर्थ है, तो यह चुपचाप कुछ त्याग देगा।

QTimer वर्ग सिंगल-शॉट टाइमर और घड़ी संकेतों के बजाय घटनाओं के साथ एक उच्च स्तरीय प्रोग्रामिंग इंटरफेस प्रदान करता है। वहाँ भी एक है QBasicTimer वर्ग की तुलना में अधिक हल्के है कि QTimer और सीधे टाइमर आईडी का उपयोग कम से कम अनाड़ी।

यह फ़ंक्शन Qt 5.9 में पेश किया गया था।

timerEvent भी देखें (), killTimer (), और QTimer::singleShot ()।

QThread * QObject :: धागा () स्थिरांक

वह धागा लौटाता है जिसमें वस्तु रहती है।

moveToThread () भी देखें

[virtual protected] शून्य QObject :: टाइमरईवेंट ( QTimerEvent * घटना )

इस इवेंट हैंडलर को ऑब्जेक्ट के लिए टाइमर इवेंट प्राप्त करने के लिए एक उपवर्ग में फिर से लागू किया जा सकता है।

QTimer टाइमर कार्यक्षमता के लिए एक उच्च-स्तरीय इंटरफ़ेस प्रदान करता है, और टाइमर के बारे में अधिक सामान्य जानकारी भी। टाइमर इवेंट इवेंट पैरामीटर में पारित किया गया है ।

यह भी देखें startTimer (), killTimer (), और event ()।

[static] QString QObject :: टीआर (स्थिरांक चार * sourceText , स्थिरांक चार * बहुविकल्पी = Q_OBJECT, int n = Q_OBJECT)

SourceText के अनुवादित संस्करण को लौटाता है , वैकल्पिक रूप से एक असंतुलित स्ट्रिंग पर आधारित होता है और plurals युक्त स्ट्रिंग्स के लिए n का मान ; अन्यथा रिटर्न QString::fromUtf8 ( sourceText ) यदि कोई उचित अनुवादित स्ट्रिंग उपलब्ध है।

उदाहरण:

void MainWindow::createActions()
{
    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
    ...

यदि समान संदर्भ में एक ही स्रोतटैक्स का उपयोग अलग-अलग भूमिकाओं में किया जाता है, तो एक अतिरिक्त पहचान स्ट्रिंग को संवितरण (डिफ़ॉल्ट रूप से 0) में पारित किया जा सकता है । क्यूटी 4.4 और इससे पहले में, यह अनुवादकों के लिए टिप्पणियों को पारित करने का पसंदीदा तरीका था।

उदाहरण:

MyWindow::MyWindow()
{
    QLabel *senderLabel = new QLabel(tr("Name:"));
    QLabel *recipientLabel = new QLabel(tr("Name:", "recipient"));
    ...

देखें अनुवाद के लिए लेखन स्रोत कोड सामान्य रूप में क्यूटी के अनुवाद तंत्र का विस्तृत वर्णन है, और के लिए Disambiguation बहुविकल्पी के बारे में जानकारी के लिए खंड।

चेतावनी: यह विधि केवल तभी है जब इस पद्धति को कॉल करने से पहले सभी अनुवादक स्थापित किए जाते हैं । अनुवाद करते समय अनुवादकों को स्थापित करना या हटाना समर्थित नहीं है। ऐसा करने से संभवतः क्रैश या अन्य अवांछनीय व्यवहार होगा।

QCoreApplication::translate Qt के साथ QCoreApplication::translate () और अंतर्राष्ट्रीयकरण भी देखें

सदस्य चर प्रलेखन

स्थिरांक QMetaObject QObject :: staticMetaObject

यह चर वर्ग के लिए मेटा-ऑब्जेक्ट को संग्रहीत करता है।

एक मेटा-ऑब्जेक्ट में एक वर्ग के बारे में जानकारी होती है जो QObject , जैसे वर्ग का नाम, QObject नाम, गुण, सिग्नल और स्लॉट विरासत में QObject । प्रत्येक वर्ग जिसमें Q_OBJECT मैक्रो होता है, Q_OBJECT एक मेटा-ऑब्जेक्ट भी होगा।

मेटा-ऑब्जेक्ट जानकारी सिग्नल / स्लॉट कनेक्शन तंत्र और संपत्ति प्रणाली द्वारा आवश्यक है। inherits () फ़ंक्शन भी मेटा-वस्तु का उपयोग करता है।

यदि आपके पास किसी ऑब्जेक्ट का पॉइंटर है, तो आप उस ऑब्जेक्ट से जुड़े मेटा-ऑब्जेक्ट को पुनः प्राप्त करने के लिए metaObject () का उपयोग कर सकते हैं ।

उदाहरण:

QPushButton::staticMetaObject.className();  // returns "QPushButton"

QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns "QPushButton"

metaObject () भी देखें

संबंधित गैर-सदस्य

T qobject_cast ( QObject * ऑब्जेक्ट )

T qobject_cast (const QObject * ऑब्जेक्ट )

दिए गए ऑब्जेक्ट को टाइप T पर लौटाता है यदि ऑब्जेक्ट टाइप T (या उपवर्ग का) है; अन्यथा वापस लौटाता है। यदि वस्तु 0 है तो वह भी 0 होगी।

वर्ग T को (प्रत्यक्ष या अप्रत्यक्ष रूप से) QObject वारिस होना चाहिए और Q_OBJECT मैक्रो के साथ घोषित किया जाना चाहिए ।

एक वर्ग को विरासत में ही माना जाता है।

उदाहरण:

QObject *obj = new QTimer;          // QTimer inherits QObject

QTimer *timer = qobject_cast<QTimer *>(obj);
// timer == (QObject *)obj

QAbstractButton *button = qobject_cast<QAbstractButton *>(obj);
// button == 0

qobject_cast () फ़ंक्शन मानक C ++ qobject_cast () के समान व्यवहार करता है, उन लाभों के साथ जिन्हें यह RTTI समर्थन की आवश्यकता नहीं है और यह गतिशील लाइब्रेरी सीमाओं के पार काम करता है।

qobject_cast () का उपयोग इंटरफेस के साथ संयोजन में भी किया जा सकता है; देखने के प्लग और पेंट जानकारी के लिए उदाहरण।

चेतावनी: यदि T को Q_OBJECT मैक्रो के साथ घोषित नहीं किया गया है , तो इस फ़ंक्शन का रिटर्न मान अपरिभाषित है।

यह भी देखें inherits ()।

typedef QObjectList

QList < QObject *> का पर्यायवाची ।

QList < T > qFindChildren (const QObject * obj , const QRegExp और EXExEx )

यह फ़ंक्शन qFindChildren () को ओवरलोड करता है।

यह फ़ंक्शन obj -> findChildren <T> ( regExp ) के बराबर है

नोट: यह फ़ंक्शन MSVC 6 के लिए एक समाधान के रूप में प्रदान किया गया था जो सदस्य टेम्पलेट फ़ंक्शन का समर्थन नहीं करता था। नए फॉर्म में अन्य फॉर्म का उपयोग करने की सलाह दी जाती है।

यह भी देखें findChildren ()।

मैक्रो डॉक्यूमेंटेशन

QT_NO_NARROWING_CONVERSIONS_IN_CONNECT

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

यह फ़ंक्शन Qt 5.8 में पेश किया गया था।

यह भी देखें connect

Q_CLASSINFO ( नाम , मान )

यह मैक्रो अतिरिक्त जानकारी को वर्ग में metaObject है, जो metaObject () का उपयोग करके उपलब्ध है । Qt सक्रिय Qt , Qt D-Bus और Qt QML में इस सुविधा का केवल सीमित उपयोग करता है ।

अतिरिक्त जानकारी नाम स्ट्रिंग और मान शाब्दिक स्ट्रिंग का रूप लेती है ।

उदाहरण:

class MyClass : public QObject
{
    Q_OBJECT
    Q_CLASSINFO("Author", "Pierre Gendron")
    Q_CLASSINFO("URL", "http://www.my-organization.qc.ca")

public:
    ...
};

QMetaObject::classInfo भी देखें QMetaObject::classInfo (), QAxFactory , Qt D- बस एडेप्टर का उपयोग करके , और QML का विस्तार

Q_DISABLE_COPY ( कक्षा )

दिए गए वर्ग के लिए कॉपी कंस्ट्रक्टर और असाइनमेंट ऑपरेटरों के उपयोग को अक्षम करता है ।

QObject के उपवर्गों के QObject को उन मूल्यों के रूप में नहीं सोचा जाना चाहिए जिन्हें कॉपी या असाइन किया जा सकता है, लेकिन विशिष्ट पहचान के रूप में। इसका मतलब यह है कि जब आप QObject (डायरेक्टर या इनडायरेक्ट) का अपना उपवर्ग बनाते हैं , तो आपको इसे कॉपी कंस्ट्रक्टर या असाइनमेंट ऑपरेटर को नहीं देना चाहिए । हालाँकि, यह केवल उन्हें आपकी कक्षा से बाहर निकालने के लिए पर्याप्त नहीं हो सकता है, क्योंकि, यदि आप गलती से कुछ कोड लिखते हैं जिसके लिए एक कॉपी कंस्ट्रक्टर या असाइनमेंट ऑपरेटर की आवश्यकता होती है (यह करना आसान है), तो आपका कंपाइलर सोच-समझकर आपके लिए इसे बनाएगा। आपको अधिक करना चाहिए।

जिज्ञासु उपयोगकर्ता ने देखा होगा कि QObject से प्राप्त Qt वर्ग में आमतौर पर एक निजी अनुभाग में यह मैक्रो शामिल होता है :

class MyClass : public QObject
{

  private:
    Q_DISABLE_COPY(MyClass)
};

यह निजी अनुभाग में एक कॉपी कंस्ट्रक्टर और एक असाइनमेंट ऑपरेटर की घोषणा करता है, ताकि यदि आप गलती से उनका उपयोग करते हैं, तो कंपाइलर एक त्रुटि की रिपोर्ट करेगा।

class MyClass : public QObject
{

  private:
     MyClass(const MyClass &);
     MyClass &operator=(const MyClass &);
};

लेकिन यहां तक ​​कि यह पूरी तरह से हर मामले को पकड़ नहीं सकता है। आपको ऐसा कुछ करने के लिए लुभाया जा सकता है:

  QWidget w = QWidget();

सबसे पहले, ऐसा मत करो। अधिकांश संकलक कोड का निर्माण करेंगे जो कॉपी कंस्ट्रक्टर का उपयोग करता है, इसलिए गोपनीयता उल्लंघन की रिपोर्ट की जाएगी, लेकिन आपके सी ++ कंपाइलर को इस कथन के लिए एक विशिष्ट तरीके से कोड उत्पन्न करने की आवश्यकता नहीं है। यह तो कॉपी कंस्ट्रक्टर का उपयोग करके कोड उत्पन्न कर सकता है और न ही असाइनमेंट ऑपरेटर जिसे हमने निजी बनाया है। उस स्थिति में, किसी भी त्रुटि की सूचना नहीं दी जाएगी, लेकिन जब आप एक सदस्य फ़ंक्शन को कॉल करते हैं, तो आपका एप्लिकेशन संभवतः क्रैश हो जाएगा w

Q_EMIT

emit जब आप Qt सिग्नल और स्लॉट का उपयोग तृतीय पक्ष सिग्नल / स्लॉट तंत्र के साथ करना चाहते हैं, तो सिग्नल को बदलने के लिए इस मैक्रो का उपयोग करें ।

फ़ाइल में चर के no_keywords साथ निर्दिष्ट होने पर मैक्रो का उपयोग आमतौर पर किया जाता है , लेकिन इसका उपयोग तब भी किया जा सकता है जब निर्दिष्ट नहीं किया जाता है । CONFIG .pro no_keywords

Q_ENUM ( ... )

यह मैक्रो मेटा-ऑब्जेक्ट सिस्टम के साथ एक एनुम प्रकार को पंजीकृत करता है। Q_OBJECT या Q_GADGET मैक्रो वाले वर्ग में enum घोषणा के बाद इसे रखा जाना चाहिए । नामस्थान के लिए इसके बजाय Q_ENUM_NS () का उपयोग करें।

उदाहरण के लिए:

class MyClass : public QObject
{
    Q_OBJECT

public:
    MyClass(QObject *parent = 0);
    ~MyClass();

    enum Priority { High, Low, VeryHigh, VeryLow };
    Q_ENUM(Priority)
    void setPriority(Priority priority);
    Priority priority() const;
};

Enumerations कि Q_ENUM साथ घोषित किया गया है उनके लिए है QMetaEnum enclosing में पंजीकृत QMetaObject । तुम भी उपयोग कर सकते हैं QMetaEnum::fromType () प्राप्त करने के लिए QMetaEnum

पंजीकृत QMetaType स्वचालित रूप से Qt मेटा टाइप सिस्टम में भी पंजीकृत होते हैं, जिससे उन्हें Q_DECLARE_METATYPE () का उपयोग करने की आवश्यकता के बिना QMetaType लिए जाना जाता है । यह उपयोगी सुविधाओं को सक्षम करेगा; उदाहरण के लिए, यदि QVariant में उपयोग किया जाता है, तो आप उन्हें स्ट्रिंग्स में परिवर्तित कर सकते हैं। इसी तरह, उन्हें QDebug को पास करने से उनके नाम QDebug जाएंगे।

यह फ़ंक्शन Qt 5.5 में पेश किया गया था।

Qt की संपत्ति प्रणाली भी देखें

Q_ENUM_NS ( ... )

यह मैक्रो मेटा-ऑब्जेक्ट सिस्टम के साथ एक एनुम प्रकार को पंजीकृत करता है। Q_NAMESPACE मैक्रो वाले नाम स्थान में Q_NAMESPACE घोषणा के बाद इसे रखा जाना चाहिए । यह Q_ENUM जैसा है लेकिन किसी नाम स्थान में है।

Enumerations कि Q_ENUM_NS साथ घोषित किया गया है उनके लिए है QMetaEnum enclosing में पंजीकृत QMetaObject । तुम भी उपयोग कर सकते हैं QMetaEnum::fromType () प्राप्त करने के लिए QMetaEnum

पंजीकृत QMetaType स्वचालित रूप से Qt मेटा टाइप सिस्टम में भी पंजीकृत होते हैं, जिससे उन्हें Q_DECLARE_METATYPE () का उपयोग करने की आवश्यकता के बिना QMetaType लिए जाना जाता है । यह उपयोगी सुविधाओं को सक्षम करेगा; उदाहरण के लिए, यदि QVariant में उपयोग किया जाता है, तो आप उन्हें स्ट्रिंग्स में परिवर्तित कर सकते हैं। इसी तरह, उन्हें QDebug को पास करने से उनके नाम QDebug जाएंगे।

यह फ़ंक्शन Qt 5.8 में पेश किया गया था।

Qt की संपत्ति प्रणाली भी देखें

Q_FLAG ( ... )

यह मैक्रो मेटा-ऑब्जेक्ट सिस्टम के साथ एकल झंडे के प्रकार को पंजीकृत करता है। यह आम तौर पर एक वर्ग परिभाषा में उपयोग किया जाता है यह घोषित करने के लिए कि किसी दिए गए एनम के मूल्यों को झंडे के रूप में इस्तेमाल किया जा सकता है और बिटवाइज़ या ऑपरेटर का उपयोग करके संयुक्त किया जा सकता है। नामस्थान के लिए इसके बजाय Q_FLAG_NS () का उपयोग करें।

मैम को एनम घोषणा के बाद रखा जाना चाहिए।

उदाहरण के लिए, QLibrary , LoadHints ध्वज को निम्न तरीके से घोषित किया गया है:

class QLibrary : public QObject
{
    Q_OBJECT

public:
    ...

    enum LoadHint {
        ResolveAllSymbolsHint = 0x01,
        ExportExternalSymbolsHint = 0x02,
        LoadArchiveMemberHint = 0x04
    };
    Q_DECLARE_FLAGS(LoadHints, LoadHint)
    Q_FLAG(LoadHints)
    ...
}

झंडे की घोषणा स्वयं Q_DECLARE_FLAGS () मैक्रो का उपयोग करते हुए स्वयं QLibrary वर्ग के सार्वजनिक अनुभाग में की QLibraryQ_DECLARE_FLAGS

नोट: Q_FLAG मैक्रो मेटा-ऑब्जेक्ट सिस्टम के साथ व्यक्तिगत ध्वज मानों को पंजीकृत करने का ध्यान रखता है, इसलिए इस मैक्रो के अतिरिक्त Q_ENUM () का उपयोग करना अनावश्यक है ।

यह फ़ंक्शन Qt 5.5 में पेश किया गया था।

Qt की संपत्ति प्रणाली भी देखें

Q_FLAG_NS ( ... )

यह मैक्रो मेटा-ऑब्जेक्ट सिस्टम के साथ एकल झंडे के प्रकार को पंजीकृत करता है। इसका उपयोग एक नामस्थान में किया जाता है जिसमें Q_NAMESPACE मैक्रो है, यह घोषणा करने के लिए कि दिए गए Q_NAMESPACE मूल्यों को झंडे के रूप में इस्तेमाल किया जा सकता है और बिटवाइज़ या ऑपरेटर का उपयोग करके संयुक्त किया जा सकता है। यह Q_FLAG के समान है लेकिन एक नाम स्थान में है।

मैम को एनम घोषणा के बाद रखा जाना चाहिए।

नोट: Q_FLAG_NS मैक्रो मेटा-ऑब्जेक्ट सिस्टम के साथ व्यक्तिगत ध्वज मानों को पंजीकृत करने का ध्यान रखता है, इसलिए इस मैक्रो के अतिरिक्त Q_ENUM_NS () का उपयोग करना अनावश्यक है ।

यह फ़ंक्शन Qt 5.8 में पेश किया गया था।

Qt की संपत्ति प्रणाली भी देखें

Q_GADGET

Q_GADGET मैक्रो का एक हल्का संस्करण है Q_OBJECT क्लासेस से विरासत में नहीं आता के लिए मैक्रो QObject लेकिन अभी भी द्वारा की पेशकश की प्रतिबिंब क्षमताओं में से कुछ का उपयोग करना चाहते QMetaObject Q_OBJECT मैक्रो की तरह , यह एक वर्ग परिभाषा के निजी अनुभाग में दिखाई देना चाहिए।

Q_GADGETs में Q_ENUM , Q_PROPERTY और Q_INVOKABLE हो सकते हैं, लेकिन उनमें सिग्नल या स्लॉट नहीं हो सकते

Q_GADGET एक वर्ग सदस्य बनाता है staticMetaObject , उपलब्ध है। staticMetaObject प्रकार का है QMetaObject और enums Q_ENUMS साथ घोषित करने के लिए पहुँच प्रदान करता है।

Q_INTERFACES ( ... )

यह मैक्रो Qt को बताता है जो क्लास के इम्प्लीमेंट्स को बाधित करता है। प्लगइन्स को लागू करते समय इसका उपयोग किया जाता है।

उदाहरण:

class BasicToolsPlugin : public QObject,
                         public BrushInterface,
                         public ShapeInterface,
                         public FilterInterface
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.Examples.PlugAndPaint.BrushInterface" FILE "basictools.json")
    Q_INTERFACES(BrushInterface ShapeInterface FilterInterface)

public:
    ...
};

विवरण के लिए प्लग एंड पेंट मूल उपकरण उदाहरण देखें।

यह भी देखें Q_DECLARE_INTERFACE (), Q_PLUGIN_METADATA (), और कैसे क्यूटी प्लगइन्स बनाने के लिए

Q_INVOKABLE

इस मैक्रो को सदस्य कार्यों की घोषणाओं पर लागू करें ताकि उन्हें मेटा-ऑब्जेक्ट सिस्टम के माध्यम से लागू किया जा सके। मैक्रो को रिटर्न प्रकार से पहले लिखा जाता है, जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:

class Window : public QWidget
{
    Q_OBJECT

public:
    Window();
    void normalMethod();
    Q_INVOKABLE void invokableMethod();
};

invokableMethod() समारोह Q_INVOKABLE का उपयोग कर, जिससे यह मेटा-वस्तु प्रणाली के साथ पंजीकृत होने के लिए और सक्रिय करने के इसे प्रयोग लागू किया जा करने के लिए चिह्नित किया गया है QMetaObject::invokeMethod ()। चूंकि normalMethod() फ़ंक्शन इस तरह से पंजीकृत नहीं है, इसलिए QMetaObject::invokeMethod () का उपयोग करके इसे लागू नहीं किया जा सकता है ।

Q_NAMESPACE

Q_NAMESPACE मैक्रो जोड़ने के लिए इस्तेमाल किया जा सकता QMetaObject एक नाम स्थान के लिए क्षमताओं।

Q_NAMESPACE में Q_CLASSINFO , Q_ENUM_NS , Q_FLAG_NS हो सकते हैं, लेकिन उनके पास Q_ENUM , Q_FLAG , Q_PROPERTY , Q_INVOKABLE , सिग्नल नहीं या स्लॉट हो सकते हैं।

Q_NAMESPACE एक बाहरी चर बनाता है staticMetaObject , उपलब्ध है। staticMetaObject प्रकार का है QMetaObject और enums के साथ घोषित करने के लिए पहुँच प्रदान करता है Q_ENUM_NS / Q_FLAG_NS

यह फ़ंक्शन Qt 5.8 में पेश किया गया था।

Q_OBJECT

Q_OBJECT मैक्रो को एक वर्ग परिभाषा के निजी खंड में दिखाई देना चाहिए जो अपने स्वयं के सिग्नल और स्लॉट की घोषणा करता है या जो Qt की मेटा-ऑब्जेक्ट सिस्टम द्वारा प्रदान की गई अन्य सेवाओं का उपयोग करता है।

उदाहरण के लिए:

#include <QObject>

class Counter : public QObject
{
    Q_OBJECT

public:
    Counter() { m_value = 0; }

    int value() const { return m_value; }

public slots:
    void setValue(int value);

signals:
    void valueChanged(int newValue);

private:
    int m_value;
};

नोट: इस मैक्रो के लिए वर्ग को QObject उपवर्ग होना चाहिए । एक वर्ग जो कि QObject उपवर्ग नहीं है, में enums के लिए मेटा ऑब्जेक्ट सिस्टम के समर्थन को सक्षम करने के लिए Q_GADGET बजाय Q_GADGET उपयोग करें । QObject

मेटा-ऑब्जेक्ट सिस्टम , सिग्नल और स्लॉट और Qt का प्रॉपर्टी सिस्टम भी देखें

Q_PROPERTY ( ... )

इस मैक्रो का उपयोग QObject प्राप्त करने वाली कक्षाओं में गुणों की घोषणा के लिए किया जाता है । गुण वर्ग डेटा सदस्यों की तरह व्यवहार करते हैं, लेकिन मेटा-ऑब्जेक्ट सिस्टम के माध्यम से उनके पास अतिरिक्त सुविधाएं उपलब्ध हैं ।

Q_PROPERTY(type name
           (READ getFunction [WRITE setFunction] |
            MEMBER memberName [(READ getFunction | WRITE setFunction)])
           [RESET resetFunction]
           [NOTIFY notifySignal]
           [REVISION int]
           [DESIGNABLE bool]
           [SCRIPTABLE bool]
           [STORED bool]
           [USER bool]
           [CONSTANT]
           [FINAL])

संपत्ति का नाम और प्रकार और READ फ़ंक्शन आवश्यक हैं। प्रकार QVariant द्वारा समर्थित किसी भी प्रकार का हो सकता है , या यह उपयोगकर्ता द्वारा परिभाषित प्रकार हो सकता है। अन्य आइटम वैकल्पिक हैं, लेकिन एक WRITE फ़ंक्शन आम है। विशेषताएँ डिफ़ॉल्ट को छोड़कर सत्य है USER , जो असत्य को परिभाषित करता है।

उदाहरण के लिए:

Q_PROPERTY(QString title READ title WRITE setTitle USER true)

इस मैक्रो का उपयोग कैसे करें, और इसके उपयोग का अधिक विस्तृत उदाहरण के बारे में अधिक जानकारी के लिए, Qt के प्रॉपर्टी सिस्टम पर चर्चा देखें ।

Qt की संपत्ति प्रणाली भी देखें

Q_REVISION

मेटा-ऑब्जेक्ट सिस्टम में एक संशोधन संख्या के साथ उन्हें टैग करने के लिए सदस्य कार्यों की घोषणा के लिए इस मैक्रो को लागू करें। मैक्रो को रिटर्न प्रकार से पहले लिखा जाता है, जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:

class Window : public QWidget
{
    Q_OBJECT
    Q_PROPERTY(int normalProperty READ normalProperty)
    Q_PROPERTY(int newProperty READ newProperty REVISION 1)

public:
    Window();
    int normalProperty();
    int newProperty();
public slots:
    void normalMethod();
    Q_REVISION(1) void newMethod();
};

मेटा-ऑब्जेक्ट सिस्टम का उपयोग गतिशील रूप से वस्तुओं को किसी अन्य एपीआई से उजागर करने के लिए किया जाता है, जब आप अन्य एपीआई के कई संस्करणों से अपेक्षित संस्करण का मिलान कर सकते हैं। निम्नलिखित सरलीकृत उदाहरण पर विचार करें:

    Window window;
    int expectedRevision = 0;
    const QMetaObject *windowMetaObject = window.metaObject();
    for (int i=0; i < windowMetaObject->methodCount(); i++)
        if (windowMetaObject->method(i).revision() <= expectedRevision)
            exposeMethod(windowMetaObject->method(i));
    for (int i=0; i < windowMetaObject->propertyCount(); i++)
        if (windowMetaObject->property(i).revision() <= expectedRevision)
            exposeProperty(windowMetaObject->property(i));

पिछले उदाहरण के रूप में एक ही विंडो क्लास का उपयोग करते हुए, newProperty और newMethod केवल इस कोड में उजागर किया जाएगा जब अपेक्षित संस्करण 1 या अधिक हो।

चूँकि सभी विधियाँ संशोधन 0 में मानी जाती हैं, यदि कोई खंडित नहीं है, तो Q_REVISION (0) का एक टैग अमान्य और उपेक्षित है।

इस टैग का उपयोग मेटा-ऑब्जेक्ट सिस्टम द्वारा ही नहीं किया जाता है। वर्तमान में यह केवल QtQml मॉड्यूल द्वारा उपयोग किया जाता है ।

अधिक सामान्य स्ट्रिंग टैग के लिए, QMetaMethod::tag () देखें

QMetaMethod::revision () भी देखें

Q_SET_OBJECT_NAME ( ऑब्जेक्ट )

यह मैक्रो ऑब्जेक्ट ऑब्जेक्ट "ऑब्जेक्ट" को असाइन करता है ।

इससे कोई फर्क नहीं पड़ता कि ऑब्जेक्ट पॉइंटर है या नहीं, मैक्रो आंकड़े जो खुद से बाहर निकलते हैं।

यह फ़ंक्शन Qt 5.0 में पेश किया गया था।

objectName () भी देखें

Q_SIGNAL

यह एक अतिरिक्त मैक्रो है जो आपको सिग्नल के रूप में एकल फ़ंक्शन को चिह्नित करने की अनुमति देता है। यह काफी उपयोगी हो सकता है, खासकर जब आप एक 3-पक्ष स्रोत कोड पार्सर जो एक नहीं समझती का उपयोग signals या Q_SIGNALS समूहों।

signals जब आप Qt सिग्नल और स्लॉट का उपयोग तृतीय पक्ष सिग्नल / स्लॉट तंत्र के साथ करना चाहते हैं, तो इस मैक्रो का उपयोग कक्षा की घोषणाओं में करें ।

फ़ाइल में चर के no_keywords साथ निर्दिष्ट होने पर मैक्रो का उपयोग आमतौर पर किया जाता है , लेकिन इसका उपयोग तब भी किया जा सकता है जब निर्दिष्ट नहीं किया जाता है । CONFIG .pro no_keywords

Q_SIGNALS

signals जब आप Qt सिग्नल और स्लॉट का उपयोग तृतीय पक्ष सिग्नल / स्लॉट तंत्र के साथ करना चाहते हैं, तो इस मैक्रो का उपयोग कक्षा की घोषणाओं में करें ।

फ़ाइल में चर के no_keywords साथ निर्दिष्ट होने पर मैक्रो का उपयोग आमतौर पर किया जाता है , लेकिन इसका उपयोग तब भी किया जा सकता है जब निर्दिष्ट नहीं किया जाता है । CONFIG .pro no_keywords

Q_SLOT

यह एक अतिरिक्त मैक्रो है जो आपको एक फ़ंक्शन को स्लॉट के रूप में चिह्नित करने की अनुमति देता है। यह काफी उपयोगी हो सकता है, खासकर जब आप एक 3-पक्ष स्रोत कोड पार्सर जो एक नहीं समझती का उपयोग slots या Q_SLOTS समूहों।

slots जब आप Qt सिग्नल और स्लॉट का उपयोग तृतीय पक्ष सिग्नल / स्लॉट तंत्र के साथ करना चाहते हैं, तो इस मैक्रो का उपयोग कक्षा की घोषणाओं में करें ।

फ़ाइल में चर के no_keywords साथ निर्दिष्ट होने पर मैक्रो का उपयोग आमतौर पर किया जाता है , लेकिन इसका उपयोग तब भी किया जा सकता है जब निर्दिष्ट नहीं किया जाता है । CONFIG .pro no_keywords

Q_SLOTS

slots जब आप Qt सिग्नल और स्लॉट का उपयोग तृतीय पक्ष सिग्नल / स्लॉट तंत्र के साथ करना चाहते हैं, तो इस मैक्रो का उपयोग कक्षा की घोषणाओं में करें ।

फ़ाइल में चर के no_keywords साथ निर्दिष्ट होने पर मैक्रो का उपयोग आमतौर पर किया जाता है , लेकिन इसका उपयोग तब भी किया जा सकता है जब निर्दिष्ट नहीं किया जाता है । CONFIG .pro no_keywords

Original text