क्यूएमएल और सी ++। हम डेटा ड्राइव करते हैं, बातचीत की गति का मूल्यांकन करते हैं

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

आइए QML से C ++ और इसके विपरीत डेटा पास करने के सबसे स्पष्ट तरीकों के एक जोड़े को देखें। हम उनकी प्रभावशीलता का मूल्यांकन भी करेंगे।

खैर, शुरू करते हैं

हम सरलतम चीज़ को ध्यान में रखते हैं: पाठ के साथ एक खिड़की होती है, जब आप पाठ पर क्लिक करते हैं, तो हमें इस पाठ के साथ कुछ जोड़तोड़ करने की आवश्यकता है c ++ का उपयोग करके और फिर उसी विंडो में अंतिम संस्करण दिखाएं।

इस तरह के मुश्किल काम के लिए पहला कार्यान्वयन विकल्प: क्यूएमएल से, हम सी ++ वर्ग में वर्णित स्लॉट को कॉल करते हैं और इसके लिए हमारे पाठ को पास करते हैं। टेक्स्ट को बदलने के बाद, हम सिग्नल को कॉल करते हैं और इस सिग्नल के साथ हम बदले हुए टेक्स्ट को QML में ट्रांसमिट करते हैं।

फ़ाइल main.cpp | हम उस वर्ग का एक उदाहरण बनाते हैं जिसमें हमारे सिग्नल और स्लॉट का वर्णन किया गया है, एक संदर्भ संपत्ति घोषित करें (जैसे कि हम qml में हमारी कक्षा के लिए एक लिंक पास करें)

#include <QApplication> #include "qmlapplicationviewer.h" #include <QDeclarativeContext> #include "asd.h" Q_DECL_EXPORT int main(int argc, char *argv[]) { QScopedPointer<QApplication> app(createApplication(argc, argv)); QmlApplicationViewer viewer; asd ASD; viewer.rootContext()->setContextProperty("ASD", &ASD); viewer.setOrientation(QmlApplicationViewer::ScreenOrientationAuto); viewer.setMainQmlFile(QLatin1String("qml/habr1/main.qml")); viewer.showExpanded(); return app->exec(); } 

Asd.h फ़ाइल (सिग्नल और स्लॉट के साथ हमारी कक्षा का शीर्षक)

 #ifndef ASD_H #define ASD_H #include <QObject> class asd : public QObject { Q_OBJECT public: explicit asd(QObject *parent = 0); signals: void transmitNewText(QString text); public slots: void getOldText(QString text); }; #endif // ASD_H 

फ़ाइल asd.cpp (हमारे स्लॉट का वर्णन करें) | जैसा कि आप कोड से देख सकते हैं, स्लॉट पाठ प्राप्त करता है, इसमें एक शब्द जोड़ता है, और फिर एक सिग्नल कॉल करता है

 #include "asd.h" asd::asd(QObject *parent) : QObject(parent) { } void asd::getOldText(QString text){ emit transmitNewText(text + " Hello!"); } 

खैर, main.qml (पाठ के साथ हमारी खिड़की) | माउस बटन दबाकर (onClicked) हम स्लॉट को कॉल करते हैं और सिग्नल (onTransmitNewText) की प्रतीक्षा करते हैं, जिसके प्राप्त होने पर हम अपनी विंडो में संदेश टेक्स्ट बदलते हैं

 import QtQuick 1.1 Rectangle { width: 360 height: 360 Connections { target: ASD onTransmitNewText: text1.text = text } Text { id: text1 text: qsTr("Hello World.") anchors.centerIn: parent } MouseArea { anchors.fill: parent onClicked: ASD.getOldText(text1.text) } } 

इससे बोरिंग हिस्सा खत्म हो जाता है। आइए इसे चालू करें और देखें कि स्लॉट को कॉल करने और सिग्नल के साथ हमारे संशोधित पाठ को भेजने में कितना समय लगता है।



प्रयोग की शुद्धता के लिए, पाठ पर 20 बार क्लिक करें:


हम "सिग्नल" नामक दो पंक्तियों को देखते हैं। हम समयरेखा खोलते हैं, सुनिश्चित करें कि पूरी प्रक्रिया की गति का अनुमान लगाने के लिए, हमें अपनी तस्वीर से केवल शीर्ष रेखा की आवश्यकता है, क्योंकि यह सिग्नल पूरा होने तक कॉल की शुरुआत से लेकर स्लॉट तक रहता है:


दूसरा कार्यान्वयन विकल्प: जब आप पाठ पर क्लिक करते हैं, तो हम एक सिग्नल उत्पन्न करते हैं, इस सिग्नल को पहले से परिचित एक वर्ग के स्लॉट से कनेक्ट करते हैं, जिसके बाद हम उसी सिग्नल को उसी तरह से कॉल करते हैं, जिस तरह से टेक्स्ट बदलने के बाद और QML में वर्णित स्लॉट के साथ इसका जवाब देते हैं।

पहली नज़र में, ऐसा लग सकता है कि इसके लिए पहले अवतार की तुलना में अधिक समय की आवश्यकता होगी।

हम अपने main.cpp को बदलते हैं (यहां सब कुछ सरल और स्पष्ट है, हम स्लॉट और सिग्नल कनेक्ट करते हैं)

 #include <QApplication> #include "qmlapplicationviewer.h" #include <QGraphicsObject> #include "asd.h" Q_DECL_EXPORT int main(int argc, char *argv[]) { QScopedPointer<QApplication> app(createApplication(argc, argv)); QmlApplicationViewer viewer; viewer.setOrientation(QmlApplicationViewer::ScreenOrientationAuto); viewer.setMainQmlFile(QLatin1String("qml/habr2/main.qml")); asd ASD; QObject *qml = viewer.rootObject(); QObject::connect(qml, SIGNAL(transmitOldText(QString)), &ASD, SLOT(getOldText(QString))); QObject::connect(&ASD, SIGNAL(transmitNewText(QVariant)), qml, SLOT(getNewText(QVariant))); viewer.showExpanded(); return app->exec(); } 

asd.h (हमारी कक्षा का शीर्षक थोड़ा बदलिए ) | क्योंकि किसी फ़ंक्शन को परिभाषित करने वाले qml में, आप डेटा प्रकार को स्पष्ट रूप से निर्दिष्ट नहीं कर सकते, आपको QString को QVariant से बदलना होगा

 #ifndef ASD_H #define ASD_H #include <QObject> #include <QVariant> class asd : public QObject { Q_OBJECT public: explicit asd(QObject *parent = 0); signals: void transmitNewText(QVariant text); public slots: void getOldText(QString text); }; #endif // ASD_H 

asd.cpp (वही QVariant जोड़ा गया)

 #include "asd.h" asd::asd(QObject *parent) : QObject(parent) { } void asd::getOldText(QString text){ emit transmitNewText(QVariant(text + " Hello!")); } 

खैर, हमारी नई main.qml विंडो

 import QtQuick 1.1 Rectangle { id: rth width: 360 height: 360 function getNewText(text){ text1.text = text } signal transmitOldText(string text) Text { id: text1 text: qsTr("Hello World.") anchors.centerIn: parent } MouseArea { anchors.fill: parent onClicked: transmitOldText(text1.text) } } 

आइए देखें कि इस समय हमें कितना समय चाहिए:

पाठकों के अनुरोध पर, हम अपने परीक्षण को एक फ़ंक्शन में जोड़ते हैं जो एक मान लौटाता है

इसलिए, main.cpp पहले संस्करण में जैसा था वैसा ही बना हुआ है। हम सभी एक संदर्भ संपत्ति (अपनी कक्षा के उदाहरण के लिए) की घोषणा करते हैं

 asd ASD; viewer.rootContext()->setContextProperty("ASD", &ASD); 

हमारे C ++ स्लॉट को थोड़ा संशोधित करें (अब यह एक मान लौटाता है)

 QString asd::getOldTextTransmitNewText(QString text){ return text + " Hello!"; } 

जिसके बाद हम main.qml को थोड़ा बदल देते हैं

 MouseArea { anchors.fill: parent onClicked: text1.text = ASD.getOldTextTransmitNewText(text1.text) } 

चालू करें, बीते हुए समय को देखें:


केवल Q_INVOKABLE के साथ एक ही विकल्प

 Q_INVOKABLE QString getOldTextTransmitNewText(QString text); 

यह स्लॉट की तुलना में थोड़ा धीमा निकला:

संक्षेप में (याद रखें कि दी गई मिलीसेकंड 20 कॉल के लिए राशि हैं)

पहली विधि सबसे लंबे समय तक निकली (बाद के सिग्नल पकड़ने के साथ qml से एक स्लॉट को कॉल करना): 14.885 एमएस ।
दूसरा विकल्प तेज है (जहां हमने स्लॉट और सिग्नल कनेक्ट किए हैं): 13.993 एमएस ।
सबसे तेज़ विकल्प एक फ़ंक्शन को कॉल करना है जो मान लौटाता है: 13.456 एमएस । स्लॉट और 13.508 एमएस के लिए । Q_INVOKABLE के लिए (त्रुटि के मार्जिन के भीतर)।

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

यह सब क्यों और किसके लिए किया गया? किसी कारण के लिए, यह ठीक यही विचार था जो मेरे साथ हुआ था, क्योंकि मैंने कभी भी इस तरह के "बकवास" से निपटा नहीं था। खैर, मैंने आपके साथ परिणाम साझा करने का फैसला किया।