बस क्यूटी के बारे में। कंटेनर पुस्तकालय

हाय, हेब्र!

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

प्रविष्टि

मैं एक बात कहना चाहता हूं - लेख का उद्देश्य शुरुआत के प्रोग्रामर हैं। हम जारी रखते हैं।

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

QVector वेक्टर

वेक्टर एक डेटा संरचना है जो एक नियमित सरणी के समान है। हालांकि, सदिश वर्ग का उपयोग करने से एक साधारण सरणी पर कुछ फायदे मिलते हैं। उदाहरण के लिए, आप वेक्टर (इसके आकार) के अंदर तत्वों की संख्या का पता लगा सकते हैं, या गतिशील रूप से इसका विस्तार कर सकते हैं। यह कंटेनर अन्य प्रकार के कंटेनरों की तुलना में अधिक किफायती भी है। अनुक्रमिक कंटेनर के अंत में तत्वों को जोड़ने के लिए, आप पुश_बैक () विधि का उपयोग कर सकते हैं। वेक्टर के तत्वों को अनुक्रमणिका ऑपरेटर [] के माध्यम से पहुँचा जा सकता है, और पुनरावृत्त का उपयोग किया जा सकता है। उदाहरण के लिए:

QVector<int> vec; vec.push_back(10); //      vec.push_back(20); vec.push_back(30); qDebug() << vec; 

यह कटौती की जाएगी - QVector (10,20,30) ।

QByteArray बाइट ऐरे

यह कंटेनर QVector के समान है, लेकिन अंतर यह है कि यह टेम्पलेट क्लास नहीं है , और यह केवल उन तत्वों के भंडारण की अनुमति देता है जो आकार में एक बाइट हैं। जहाँ भी मध्यवर्ती डेटा भंडारण की आवश्यकता होती है, वहां QByteArray के प्रकार का उपयोग किया जा सकता है। सरणी तत्वों की संख्या को कंस्ट्रक्टर में सेट किया जा सकता है, और [] ऑपरेटर का उपयोग करके उन तक पहुंच बनाई जा सकती है।

 QByteArray arr(3); arr[0] = arr[1] = 0xFF; arr[2] = 0x0; 

आप QByteArray वर्ग की वस्तुओं के डेटा के लिए संपीड़न ऑपरेशन और उलटा परिवर्तन भी लागू कर सकते हैं। यह दो वैश्विक कार्यों qCompress () और qUncompress () का उपयोग करके प्राप्त किया जाता है। बस डेटा संपीड़ित और विघटित करें:

 QByteArray a = "Some text..."; QByteArray aCompressed = qCompress(a); qDebug << qUncompress(aCompressed); 

कुछ पाठ ... प्रदर्शित किए जाएंगे।

QBitArray बिट ऐरे

यह वर्ग थोड़ा (या बूलियन ) सरणी का प्रबंधन करता है। संग्रहीत मेमोरी में से प्रत्येक अतिरिक्त मेमोरी को बर्बाद किए बिना केवल एक बिट लेता है। इस प्रकार का उपयोग बड़ी संख्या में प्रकार के बूल को संग्रहीत करने के लिए किया जाता है।

 QBitArray arr(3); arr[0] = arr[1] = true; arr[2] = false; 

QList और QLinkedList सूचियाँ

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

सूचियाँ QList टेम्पलेट वर्ग द्वारा कार्यान्वित की जाती हैं। सामान्य तौर पर, यह वर्ग तत्वों की ओर संकेत करता है।

सूचियों के साथ काम करने के लिए विशिष्ट संचालन:

• चाल () - एक तत्व को एक स्थिति से दूसरे स्थान पर ले जाता है।
• removeFirst () - किसी सूची का पहला तत्व निकालता है ।
• removeLast () - किसी सूची में अंतिम आइटम को हटाता है ।
• स्वैप () - निर्दिष्ट पदों पर एक सूची के दो तत्वों को स्वैप करता है।
• takeAt () - आइटम को निर्दिष्ट स्थान पर लौटाता है और सूची से निकालता है।
• takeFirst () - पहला तत्व देता है और इसे सूची से निकाल देता है।
• takeLast () - अंतिम आइटम लौटाता है और सूची से निकालता है।
• toSet () - सूची में शामिल डेटा के साथ एक QSet कंटेनर लौटाता है।
• toStdList () - मानक STL सूची std :: सूची से तत्वों के साथ सूची लौटाता है ।
• toVector () - सूची में शामिल डेटा के साथ QVector वेक्टर लौटाता है।

यदि आप तत्वों के मूल्यों को बदलने नहीं जा रहे हैं, तो, दक्षता के कारणों के लिए, [] ऑपरेटर का उपयोग करने की अनुशंसा नहीं की जाती है। इसके बजाय () विधि का उपयोग करें, क्योंकि यह तत्व के लिए एक निरंतर संदर्भ देता है।

सबसे आम ऑपरेशनों में से एक है सूची को क्रमवार रूप से प्रत्येक सूची आइटम के मूल्यों को पुनः प्राप्त करना। उदाहरण के लिए:

 QList<int> list; list << 10 << 20 << 30; QValueList<int>::iterator it = list.begin(); //         while (it != list.end()) { qDebug() << "Element:" << *it; ++it; } 

कंसोल प्रदर्शित करेगा:
तत्व: १०
तत्व: २०
तत्व: ३०

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

स्टैक ऑफ़ क्स्टैक

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

QStack वर्ग स्टैक संरचना का एक कार्यान्वयन है। यह वर्ग QVector से विरासत में मिला है। स्टैक पर आइटम डालने की प्रक्रिया को आमतौर पर धक्का कहा जाता है, और इसमें से शीर्ष आइटम को पॉपिंग कहा जाता है। प्रत्येक पुश ऑपरेशन 1 से स्टैक का आकार बढ़ाता है, और प्रत्येक पुश ऑपरेशन 1 से कम हो जाता है। इन कार्यों के लिए, QStack वर्ग में पुश () और पॉप () फ़ंक्शन परिभाषित होते हैं। शीर्ष () विधि शीर्ष तत्व के लिए एक लिंक देता है। ढेर उपयोग उदाहरण:

 QStack<QString> stk; stk.push("Era"); //        stk.push("Corvus Corax"); stk.push("Gathering"); while (!stk.empty()) { qDebug() << "Element:" << stk.pop(); } 

कंसोल में होगा:
तत्व: "सभा"
तत्व: "कोरवस कोरेक्स"
तत्व: "युग"

QQueue कतार

एक कतार एक डेटा संरचना को लागू करती है जो सिद्धांत के अनुसार काम करती है - पहले आओ, पहले पाओ। QQueue वर्ग में एक कतार लागू की गई , जो QList से विरासत में मिली है।

निम्न उदाहरण कतार का उपयोग करने का एक उदाहरण प्रदर्शित करता है:

 QQueue<QString> que; que.enqueue("Era"); que.enqueue("Corvus Corax"); que.enqueue("Gathering"); while (!que.empty()) { qDebug() << "Element:" << que.dequeue(); } 

कंसोल में होगा:
तत्व: "युग"
तत्व: "कोरवस कोरेक्स"
तत्व: "सभा"

डिक्शनरी QMap, QMultiMap

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

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

QMap ऑब्जेक्ट बनाते समय, आपको इसके आकार को कंस्ट्रक्टर के पास भेजना होगा। यह आकार नहीं है, जैसा कि अन्य कंटेनर वर्गों में प्रथागत है, एक आकार जो तत्वों की अधिकतम संख्या को सीमित करता है, लेकिन पदों की संख्या का प्रतिनिधित्व करता है। पदों की संख्या संग्रहीत किए जाने वाले अपेक्षित तत्वों की संख्या से अधिक होनी चाहिए, अन्यथा शब्दकोश में तत्वों की खोज प्रभावी रूप से पर्याप्त रूप से नहीं की जाएगी। यह वांछनीय है कि यह मूल्य primes की श्रेणी से संबंधित है, क्योंकि इस मामले में तत्वों का प्लेसमेंट अधिक सुविधाजनक होगा।

कुछ तरीके:

• iowerBound () - दिए गए कुंजी के साथ पहले तत्व पर लौटता है ।
• toStdMap () - हमारे शब्दकोश के तत्वों के साथ एक एसटीएल शब्दकोश लौटाता है।
• अपरबाउंड () - दिए गए कुंजी के साथ अंतिम तत्व पर लौटता है ।

शब्दकोश आइटम तक पहुंचने के सबसे सामान्य तरीकों में से एक [] ऑपरेटर में कुंजी का उपयोग करना है। लेकिन आप इसके बिना कर सकते हैं, चूंकि कुंजी और मान को पुनरावृत्ति विधि कुंजी () और मूल्य () के माध्यम से प्राप्त किया जा सकता है, उदाहरण के लिए:

 QMap<QString,QString> mapPhonebook; mapPhonebook["Piggy"] = "+380 93 785 11 11"; mapPhonebook["Kermit"] = "+7 85 123 65 56"; mapPhonebook["Gonzo"] = "+49 73 631 32 21"; QMap<QString,QString>::iterator it = mapPhonebook.begin(); for(;it != mapPhonebook.end(); ++it) { qDebug() << "Name:" << it.key() << "Phone:" << it.value(); } 

कंसोल में होगा:
नाम: गोंजो फोन: +49 73 631 32 21
नाम: Kermit फोन: +7 85 123 65 562 21
नाम: पिग्गी फोन: +380 93 785 11 11

QHash और QMultiHash हैश

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

QMap के साथ, अनुक्रमणिका ऑपरेटर [] का उपयोग करते समय ध्यान रखा जाना चाहिए, क्योंकि एक कुंजी निर्दिष्ट करने के लिए जिसके लिए एक तत्व मौजूद नहीं है, जिससे तत्व का निर्माण होगा। इसलिए, कंटेनर के कंटेनरों () पद्धति का उपयोग करके एक कुंजी से बंधे तत्व की उपस्थिति के लिए हमेशा जांच करना महत्वपूर्ण है।

यदि आप QHash में अपनी खुद की कक्षाओं की वस्तुओं को रखने का इरादा रखते हैं, तो आपको अपनी कक्षा के लिए तुलना संचालक == और विशेष फ़ंक्शन qHash () को लागू करने की आवश्यकता होगी। यहाँ एक तुलना ऑपरेटर का एक उदाहरण कार्यान्वयन है:

 inline bool operator==(const MyClass& mc1, const MyClass& mc2) { return (mc1.firstName() == mc2.firstName() && mc1.secondName() == mc2.secondName() ); } 

QHash () फ़ंक्शन को उस संख्या को वापस करना होगा जो हैश में प्रत्येक आइटम के लिए अद्वितीय होनी चाहिए। उदाहरण के लिए:

 inline uint qHash(const MyClass& mc) { return qHash(mc.firstName()) ^ qHash(mc.secondName()); } 

QMultiHash वर्ग QHash से विरासत में मिला है। यह आपको समान कुंजी के साथ मान रखने की अनुमति देता है और सामान्य तौर पर, QMultiMap के समान है, लेकिन इसके मूल वर्ग की बारीकियों को ध्यान में रखता है।

कई क्यूसेट

जैसा कि जर्मन गणितज्ञ जॉर्ज कैंटर ने टिप्पणी की थी, "कई लोग कई हैं, जिन्हें हम मानसिक रूप से एक के रूप में समझते हैं।" यह एक, ट्यूलिप के संदर्भ में, एक QSet कंटेनर से अधिक कुछ नहीं है जो कुछ क्रम में तत्वों को लिखता है और मूल्यों को बहुत जल्दी से देखने और उनके साथ संचालन करने की क्षमता प्रदान करता है जो कि सेट की विशेषता है, जैसे कि संघ, चौराहे और अंतर। एक शर्त यह है कि चाबियाँ अलग होनी चाहिए। आप क्वसेट कंटेनर का उपयोग त्वरित डेटा पुनर्प्राप्ति के लिए एक अनियंत्रित सूची के रूप में कर सकते हैं।

संचालन जो सेट के साथ किए जा सकते हैं: संघ, अंतर, अंतर।

दो सेट बनाएं और उनमें तत्वों को लिखें:

 QSet<QString> set1; QSet<QString> set2; set1 << "Lorem" << "Ipsum" << "Dolor"; set2 << "Sit" << "Amet" << "Lorem"; 

हम इन दो सेटों के संयोजन का संचालन करते हैं, और सेट के तत्वों के अपरिवर्तित रहने के लिए, हम मध्यवर्ती सेट सेट करते हैं। सेट सेट:

 QSet<QString> setResult = set1; setResult.unite(set2); qDebug() << " = " << setResult.toList(); 

निम्नलिखित स्क्रीन पर दिखाई देगा:

संघ = ("लोरेम", "इप्सम", "डोलर", "बैठो", "आमेट")


उसी तरह, प्रतिच्छेदन () और अंतर ( घटाना) () किया जाता है।

परिणाम

आज, पाठक को सभी प्रकार के क्यूटी कंटेनरों के साथ काम करना सीखना चाहिए। आज मैंने पूरी तस्वीर का केवल एक छोटा सा हिस्सा बताया। एल्गोरिदम, नियमित अभिव्यक्तियाँ, QVariant, और बहुत कुछ आगे हैं। शायद मैं उनके बारे में लिखूंगा)।

साहित्य

1. 1. मैक्स शेली। Qt 4.5 - पेशेवर C ++ प्रोग्रामिंग
2. 2. क्यूटी संदर्भ प्रलेखन

पुनश्च यह लेख नौसिखिया प्रोग्रामर को प्रशिक्षित करने के उद्देश्य से है।