C++ वेक्टर के 30 उदाहरण

C++ में, वेक्टर एक आयामी डेटा संरचना है जो आवश्यकता के आधार पर गतिशील रूप से स्वयं को बढ़ाती है। इस डेटा संरचना में डेटा संगठन (सम्मिलन/संशोधन/हटाना) कुशलतापूर्वक किया जा सकता है। इसके अनुप्रयोगों में निम्नलिखित शामिल हैं:

1. वैज्ञानिक और इंजीनियरिंग अनुप्रयोगों में गणितीय वैक्टर का प्रतिनिधित्व करना
2. इस डेटा संरचना आदि का उपयोग करके कतारें, स्टैक लागू किए जा सकते हैं।

इस डेटा संरचना से संबंधित अधिकांश सामान्य सीआरयूडी संचालन और कार्यों पर सिंटैक्स और कोड स्निपेट्स के साथ परिदृश्य-वार विस्तार से चर्चा की गई है।

सामग्री का विषय:

1. एक वेक्टर में एक तत्व डालें
2. एक वेक्टर में एकाधिक तत्व सम्मिलित करें
3. एक वेक्टर से तत्वों तक पहुंचें
4. वेक्टर में तत्व को अद्यतन करें
5. वेक्टर से एक विशिष्ट तत्व निकालें
6. एक वेक्टर से सभी तत्व हटाएँ
7. सदिशों का संघ
8. सदिशों का प्रतिच्छेदन
9. जांचें कि वेक्टर खाली है या नहीं
10. Const_Iterator का उपयोग करके एक वेक्टर को पार करें
11. Revers_Iterator का उपयोग करके एक वेक्टर को पार करें
12. तत्वों को वेक्टर में पुश करें
13. वेक्टर से तत्वों को पॉप करें
14. वेक्टरों को स्वैप करें
15. वेक्टर से पहला तत्व प्राप्त करें
16. वेक्टर से अंतिम तत्व प्राप्त करें
17. किसी वेक्टर को नए मान निर्दिष्ट करें
18. Emplace() का उपयोग करके वेक्टर का विस्तार करें
19. Emplace_Back() का उपयोग करके वेक्टर का विस्तार करें
20. किसी वेक्टर का अधिकतम तत्व
21. वेक्टर का न्यूनतम तत्व
22. एक वेक्टर में तत्वों का योग
23. दो सदिशों का तत्व-वार गुणन
24. दो वेक्टरों का डॉट उत्पाद
25. एक सेट को एक वेक्टर में बदलें
26. डुप्लिकेट तत्वों को हटा दें
27. एक वेक्टर को एक सेट में बदलें
28. खाली स्ट्रिंग्स हटाएँ
29. किसी टेक्स्ट फ़ाइल में एक वेक्टर लिखें
30. टेक्स्ट फ़ाइल से एक वेक्टर बनाएं

एक वेक्टर में एक तत्व डालें

std::vector::insert() C++ STL में फ़ंक्शन का उपयोग तत्वों को निर्दिष्ट स्थान पर सम्मिलित करने के लिए किया जाता है।

वाक्य - विन्यास:

आइए इस फ़ंक्शन का उपयोग करें और पहली स्थिति को एक पैरामीटर के रूप में पास करें जो उस स्थिति को निर्दिष्ट करता है जहां तत्व डाला जाना है और तत्व को दूसरे पैरामीटर के रूप में प्रदान करता है।

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

आइए टाइप स्ट्रिंग का 'स्टूडेंट_नाम' वेक्टर बनाएं और इन्सर्ट() फ़ंक्शन का उपयोग करके, पहले और दूसरे स्थान पर एक के बाद एक दो स्ट्रिंग डालें।

आउटपुट:

पहले, 'छात्र_नाम' वेक्टर खाली था। सम्मिलन के बाद, वेक्टर दो तत्वों को रखता है।

एक वेक्टर में एकाधिक तत्व सम्मिलित करें

इस परिदृश्य में हम उसी फ़ंक्शन का उपयोग करते हैं जो std::vector::insert() है। लेकिन हमें एक वेक्टर में एकाधिक तत्वों को सम्मिलित करने के लिए एक ही फ़ंक्शन में अतिरिक्त/अलग-अलग पैरामीटर पास करने की आवश्यकता होती है।

परिदृश्य 1: एक ही तत्व को कई बार सम्मिलित करना

इस परिदृश्य में, हम एक ही तत्व को कई बार जोड़ते हैं।

वाक्य - विन्यास:

ऐसा करने के लिए, हमें आकार को Insert() फ़ंक्शन के दूसरे पैरामीटर के रूप में पास करना होगा। इस फ़ंक्शन को पारित किए गए कुल पैरामीटर तीन हैं।

यहाँ:

1. स्थिति पैरामीटर सम्मिलित किए जाने वाले तत्व की स्थिति निर्दिष्ट करता है। यदि आकार 1 से अधिक है, तो प्रारंभ स्थिति सूचकांक स्थिति होगी।
2. आकार पैरामीटर निर्दिष्ट करता है कि किसी तत्व को कितनी बार डाला जाना है।
3. तत्व पैरामीटर तत्व को वेक्टर में डालने के लिए लेता है।

दो स्ट्रिंग वाले 'student_names' वेक्टर पर विचार करें। दूसरे स्थान पर 'लावण्या' तार को पांच बार डालें।

आउटपुट:

मौजूदा वेक्टर में, 'श्रवण कुमार' पहले स्थान पर है और 'ललिता' दूसरे स्थान पर है। 'लावण्या' को पांच बार (दूसरे स्थान से छठे स्थान तक) डालने के बाद, 'ललिता' सातवें स्थान (अंतिम) पर आ गई।

परिदृश्य 2: एकाधिक तत्व सम्मिलित करना

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

वाक्य - विन्यास:

ऐसा करने के लिए, हमें आकार को Insert() फ़ंक्शन के दूसरे पैरामीटर के रूप में पास करना होगा। इस फ़ंक्शन को पारित किए गए कुल पैरामीटर तीन हैं।

यहाँ:

1. स्थिति पैरामीटर सम्मिलित किए जाने वाले तत्व की स्थिति निर्दिष्ट करता है।
2. 'first_iterator' प्रारंभिक स्थिति निर्दिष्ट करता है जहां से तत्वों को सम्मिलित किया जाना है (मूल रूप से, प्रारंभ() फ़ंक्शन का उपयोग करके, एक पुनरावर्तक लौटाया जाता है जो कंटेनर में मौजूद पहले तत्व को इंगित करता है)।
3. 'सेकेंड_इटरेटर' अंतिम स्थिति को निर्दिष्ट करता है जब तक कि तत्वों को सम्मिलित नहीं किया जाना है (मूल रूप से, एंड() फ़ंक्शन का उपयोग करके, एक इटरेटर वापस कर दिया जाता है जो कंटेनर में मौजूद अंतिम बिंदु के बगल में इंगित करता है)।

पूर्णांक प्रकार के दो वैक्टर, 'मार्क्स1' और 'मार्क्स2' बनाएं। 'मार्क्स2' वेक्टर में मौजूद सभी तत्वों को 'मार्क्स1' वेक्टर की पहली स्थिति में डालें।

आउटपुट:

पहले वेक्टर (मार्क्स1) में पांच तत्व होते हैं और दूसरे वेक्टर (मार्क्स2) में तीन तत्व होते हैं। हमने 'इन्सर्ट' फ़ंक्शन में आरंभ (चिह्न 1), प्रारंभ (चिह्न 2), अंत (चिह्न 2) पैरामीटर पारित किए हैं, जैसे कि दूसरे वेक्टर में मौजूद सभी तत्व पुनरावृत्त होते हैं और शुरुआत में पहले वेक्टर में डाले जाते हैं। तो, पहले वेक्टर में आठ तत्व होते हैं।

एक वेक्टर से तत्वों तक पहुंचें

1. [] ऑपरेटर का उपयोग करना

कुछ परिदृश्यों में, आपको वेक्टर से केवल विशिष्ट तत्वों को वापस करने की आवश्यकता हो सकती है। सभी तत्वों को वापस करने की आवश्यकता नहीं है. इसलिए, सूचकांक के आधार पर केवल विशिष्ट तत्वों को वापस करने के लिए, सूचकांक ऑपरेटर और at() फ़ंक्शन का उपयोग किया जाता है।

वाक्य - विन्यास:

C++ में, किसी भी डेटा संरचना के लिए अनुक्रमण 0 से शुरू होता है। यदि तत्व मौजूद नहीं है, तो यह खाली लौटता है (कोई त्रुटि या चेतावनी नहीं दी जाती है)।

पाँच वस्तुओं वाले 'उत्पाद' वेक्टर पर विचार करें। सूचकांक स्थिति का उपयोग करके सभी तत्वों को एक-एक करके एक्सेस करें।

आउटपुट:

सूचकांक 8 पर कोई तत्व मौजूद नहीं है। इसलिए, खाली लौटाया जाता है।

2. At() फ़ंक्शन का उपयोग करना

At() एक सदस्य फ़ंक्शन है जो पिछले उपयोग के मामले के समान है लेकिन यह 'std::out_of_range' अपवाद लौटाता है जब इसे सीमा से बाहर सूचकांक प्रदान किया जाता है।

वाक्य - विन्यास:

हमें इस फ़ंक्शन में अनुक्रमणिका स्थिति पास करने की आवश्यकता है।

पाँच वस्तुओं वाले 'उत्पाद' वेक्टर पर विचार करें। सूचकांक स्थिति का उपयोग करके सभी तत्वों को एक-एक करके एक्सेस करें और 9वें स्थान पर मौजूद तत्व तक पहुंचने का प्रयास करें।

आउटपुट:

9वें तत्व तक पहुँचने में त्रुटि उत्पन्न होती है:

वेक्टर में एक तत्व को अपडेट करें

1. [] ऑपरेटर का उपयोग करना

सूचकांक स्थिति का उपयोग करके, हम वेक्टर में तत्व को अपडेट कर सकते हैं। [] ऑपरेटर उस तत्व की सूचकांक स्थिति लेता है जिसे अद्यतन करना होता है। इस ऑपरेटर को नया तत्व सौंपा जाएगा।

वाक्य - विन्यास:

पाँच मानों वाले 'छात्र_चिह्न' वेक्टर पर विचार करें। सूचकांक 1 और 3 पर मौजूद तत्वों को अद्यतन करें।

आउटपुट:

हम देख सकते हैं कि अंतिम वेक्टर अद्यतन तत्वों को सूचकांक 1 और 3 पर रखता है।

2. At() फ़ंक्शन का उपयोग करना

इंडेक्स ऑपरेटर के समान, at() मूल रूप से एक सदस्य फ़ंक्शन है जो एक इटरेटर में इंडेक्स के आधार पर मान को अपडेट करता है। यदि इस फ़ंक्शन के अंदर निर्दिष्ट सूचकांक मौजूद नहीं है, तो 'std::out_of_range' अपवाद फेंक दिया जाता है।

पाँच वस्तुओं वाले 'उत्पाद' वेक्टर पर विचार करें। वेक्टर में मौजूद सभी तत्वों को अन्य तत्वों के साथ अद्यतन करें।

आउटपुट:

वेक्टर से एक विशिष्ट तत्व निकालें

C++ में, std::वेक्टर::मिटाना() फ़ंक्शन का उपयोग वेक्टर से किसी विशिष्ट तत्व/तत्वों की श्रेणी को हटाने के लिए किया जाता है। तत्वों को पुनरावर्तक स्थिति के आधार पर हटा दिया जाता है।

वाक्य - विन्यास:

आइए वेक्टर से विशिष्ट तत्व को हटाने के लिए सिंटैक्स देखें। हम हटाए जाने वाले वेक्टर में मौजूद तत्व की स्थिति प्राप्त करने के लिए शुरुआती() या अंत() फ़ंक्शन का उपयोग कर सकते हैं।

पाँच वस्तुओं वाले 'उत्पाद' वेक्टर पर विचार करें।

1. प्रारंभ() पुनरावर्तक निर्दिष्ट करके तीसरा तत्व हटाएं। शुरुआती() वेक्टर में पहले तत्व को इंगित करता है। यदि हम इस फ़ंक्शन में दो जोड़ते हैं, तो यह तीसरे तत्व की ओर इशारा करता है।
2. अंत() पुनरावर्तक को निर्दिष्ट करके अंतिम तत्व को हटा दें। End() वेक्टर में अंतिम तत्व को इंगित करता है।

आउटपुट:

अब, केवल तीन तत्व ('साबुन', 'शैंपू', 'फल') हैं जो 'उत्पाद' वेक्टर में मौजूद हैं।

एक वेक्टर से सभी तत्व हटाएँ

परिदृश्य 1: एक वेक्टर से तत्वों की एक श्रृंखला निकालें

आइए किसी श्रेणी में एकाधिक तत्वों को हटाने के लिए std::vector::erase() फ़ंक्शन का उपयोग करें।

वाक्य - विन्यास:

सीमा को निर्दिष्ट करने के लिए दो पुनरावृत्तियों (शुरू() पहले तत्व को इंगित करता है और अंत() अंतिम तत्व कार्यों को इंगित करता है) का उपयोग किया जाता है।

पांच वस्तुओं के साथ 'उत्पाद' वेक्टर पर विचार करें और सभी तत्वों को दूसरे स्थान से हटा दें। इसे प्राप्त करने के लिए, पहला पुनरावर्तक प्रारंभ (उत्पाद)+1 है जो दूसरे तत्व को इंगित करता है और दूसरा पुनरावर्तक अंत (उत्पाद) है।

आउटपुट:

अब, केवल एक तत्व ('साबुन') है जो 'उत्पाद' वेक्टर में मौजूद है।

परिदृश्य 2: वेक्टर से सभी तत्व हटाएँ

आइए उपयोग करें std::वेक्टर::स्पष्ट() वेक्टर से सभी तत्वों को हटाने का कार्य।

वाक्य - विन्यास:

इस फ़ंक्शन में कोई पैरामीटर पास नहीं किया गया है.

उसी वेक्टर पर विचार करें जिसका उपयोग पहले परिदृश्य में किया गया था और क्लियर() फ़ंक्शन का उपयोग करके सभी तत्वों को हटा दें।

आउटपुट:

हम देख सकते हैं कि 'उत्पाद' वेक्टर में कोई तत्व नहीं हैं।

सदिशों का संघ

std::set_union() फ़ंक्शन का उपयोग करके वैक्टर पर UNION ऑपरेशन करना संभव है। यूनियन डुप्लिकेट तत्वों को अनदेखा करके वैक्टर से अद्वितीय तत्व लौटाता है। हमें इस फ़ंक्शन में दोनों इटरेटर्स को पास करने की आवश्यकता है। इसके साथ ही, एक आउटपुट इटरेटर को पास करना होगा जो दोनों इटरेटर द्वारा लौटाए गए परिणाम को संग्रहीत करता है।

वाक्य - विन्यास:

यहाँ:

1. 'फर्स्ट1' पहले इटरेटर (वेक्टर) के पहले तत्व को इंगित करता है।
2. 'अंतिम1' पहले पुनरावर्तक (वेक्टर) के अंतिम तत्व को इंगित करता है।
3. 'फर्स्ट2' दूसरे इटरेटर (वेक्टर) के पहले तत्व को इंगित करता है।
4. 'अंतिम2' दूसरे पुनरावर्तक (वेक्टर) के अंतिम तत्व को इंगित करता है।

पूर्णांक प्रकार के दो वैक्टर बनाएं - 'विषय 1' और 'विषय 2'।

1. इटरेटर्स को पास करके सॉर्ट() फ़ंक्शन का उपयोग करके दो वैक्टर को सॉर्ट करें।
2. एक आउटपुट वेक्टर (इटरेटर) बनाएं।
3. std::set_union() फ़ंक्शन का उपयोग करके इन दो वैक्टरों का मिलन खोजें। पहले पुनरावर्तक के रूप में प्रारंभ() और अंतिम पुनरावर्तक के रूप में अंत() का उपयोग करें।
4. फ़ंक्शन द्वारा लौटाए गए तत्वों को प्रदर्शित करने के लिए आउटपुट वेक्टर को पुनरावृत्त करें।

आउटपुट:

दोनों वैक्टर (विषय 1 और विषय 2) में केवल पाँच अद्वितीय तत्व हैं।

सदिशों का प्रतिच्छेदन

std::set_intersection() फ़ंक्शन का उपयोग करके दो वैक्टरों के प्रतिच्छेदन का पता लगाना संभव हो सकता है। इंटरसेक्शन उन तत्वों को लौटाता है जो दोनों वैक्टर में मौजूद हैं।

वाक्य - विन्यास:

जो पैरामीटर set_union() फ़ंक्शन को पास किए जाते हैं, वे इस set_intersection() फ़ंक्शन को भी पास किए जा सकते हैं।

पूर्णांक प्रकार के दो वैक्टर बनाएं - 'विषय 1' और 'विषय 2'।

1. इटरेटर्स को पास करके सॉर्ट() फ़ंक्शन का उपयोग करके दो वैक्टर को सॉर्ट करें।
2. एक आउटपुट वेक्टर (इटरेटर) बनाएं।
3. std::set_intersection() फ़ंक्शन का उपयोग करके इन दो वैक्टरों का प्रतिच्छेदन खोजें। पहले पुनरावर्तक के रूप में प्रारंभ() और अंतिम पुनरावर्तक के रूप में अंत() का उपयोग करें।
4. फ़ंक्शन द्वारा लौटाए गए तत्वों को प्रदर्शित करने के लिए आउटपुट वेक्टर को पुनरावृत्त करें।

आउटपुट:

दोनों वैक्टर (विषय1 और विषय2) में केवल तीन तत्व मौजूद हैं।

जांचें कि वेक्टर खाली है या नहीं

वेक्टर पर काम करने से पहले यह जांचना जरूरी है कि वेक्टर खाली है या नहीं। सॉफ्टवेयर प्रोजेक्ट्स में सीआरयूडी ऑपरेशंस आदि जैसे ऑपरेशन करने से पहले यह जांचना भी एक अच्छा अभ्यास है कि वेक्टर खाली है या नहीं।

1. Std::vector::empty() का उपयोग करना

यदि वेक्टर खाली है (इसमें कोई तत्व नहीं है) तो यह फ़ंक्शन 1 लौटाता है। अन्यथा, 0 लौटाया जाता है. इस फ़ंक्शन में कोई पैरामीटर पास नहीं किया गया है.

2. का उपयोग करना एसटीडी::वेक्टर::आकार()

std::vector::size() फ़ंक्शन पूर्णांक लौटाता है जो वेक्टर में मौजूद तत्वों की कुल संख्या को दर्शाता है।

दो वेक्टर बनाएं - 'कॉलेज1' और 'कॉलेज2'। 'कॉलेज1' में पांच तत्व हैं और 'कॉलेज2' खाली है। दोनों फ़ंक्शन को दोनों वैक्टर पर लागू करें और आउटपुट की जांच करें।

आउटपुट:

खाली() फ़ंक्शन 'कॉलेज1' के लिए 0 और 'कॉलेज2' के लिए 1 लौटाता है। साइज़() फ़ंक्शन 'कॉलेज1' के लिए पांच और 'कॉलेज2' के लिए 0 देता है।

Const_Iterator का उपयोग करके एक वेक्टर को पार करें

जब आप C++ कंटेनर जैसे सेट, वैक्टर आदि पर काम कर रहे हैं, तो कंटेनर में मौजूद सभी तत्वों को संशोधित किए बिना उन पर पुनरावृति करना संभव है। const_iterator इस परिदृश्य को प्राप्त करने वाले पुनरावर्तकों में से एक है। Cbegin() (वेक्टर में पहले तत्व को इंगित करता है) और cend() (वेक्टर में अंतिम तत्व को इंगित करता है) प्रत्येक कंटेनर द्वारा प्रदान किए गए दो फ़ंक्शन हैं जिनका उपयोग निरंतर पुनरावर्तक को शुरुआत और अंत में वापस करने के लिए किया जाता है। बर्तन। वेक्टर को पुनरावृत्त करते समय, हम इन दो कार्यों का उपयोग कर सकते हैं।

1. आइए पांच तारों के साथ 'विभाग' नामक एक वेक्टर बनाएं।
2. एक const_iterator घोषित करें - प्रकार का ctr।
3. 'फॉर' लूप का उपयोग करके पिछले इटरेटर का उपयोग करके विभागों पर पुनरावृति करें और इसे प्रदर्शित करें।

आउटपुट:

Revers_Iterator का उपयोग करके एक वेक्टर को पार करें

रिवर्स_इटरेटर यह भी एक पुनरावर्तक है जो const_iterator के समान है लेकिन यह तत्वों को उल्टा लौटाता है। rbegin() (वेक्टर में अंतिम तत्व को इंगित करता है) और rend() (वेक्टर में पहले तत्व को इंगित करता है) प्रत्येक कंटेनर द्वारा प्रदान किए गए दो फ़ंक्शन हैं जिनका उपयोग स्थिर पुनरावर्तक को अंत और शुरुआत में वापस करने के लिए किया जाता है। बर्तन।

1. आइए पांच तारों के साथ 'विभाग' नामक एक वेक्टर बनाएं।
2. एक रिवर्स_इटरेटर घोषित करें - <स्ट्रिंग> प्रकार का आरटीआर।
3. 'फॉर' लूप का उपयोग करके पिछले इटरेटर का उपयोग करके विभागों पर पुनरावृति करें और इसे प्रदर्शित करें।

आउटपुट:

तत्वों को वेक्टर में पुश करें

तत्वों को वेक्टर में धकेलना या जोड़ना एक तरफ़ा सम्मिलन है जिसे इसका उपयोग करके किया जा सकता है वेक्टर::पुश_बैक() समारोह।

वाक्य - विन्यास:

वेक्टर में पैरामीटर के रूप में धकेलने के लिए एक तत्व की आवश्यकता होती है।

आइए पांच स्ट्रिंग्स के साथ 'डिपार्टमेंट्स' नामक एक खाली वेक्टर बनाएं और पुश_बैक() फ़ंक्शन का उपयोग करके दो स्ट्रिंग्स को एक के बाद एक पुश करें।

आउटपुट:

सबसे पहले, हम 'बिक्री' को आगे बढ़ाते हैं। उसके बाद, 'आईटी' को वेक्टर में धकेल दिया जाता है। अब, 'विभाग' वेक्टर में दो तत्व हैं।

वेक्टर से तत्वों को पॉप करें

यदि आप वेक्टर में मौजूद अंतिम आइटम को हटाना चाहते हैं, तो इसका उपयोग करें वेक्टर::pop_back() फ़ंक्शन सबसे अच्छा तरीका है. यह वेक्टर में मौजूद अंतिम तत्व को हटा देता है।

वाक्य - विन्यास:

इस फ़ंक्शन के लिए किसी पैरामीटर की आवश्यकता नहीं है. यदि हम किसी खाली वेक्टर से अंतिम तत्व को हटाने का प्रयास करते हैं तो यह अपरिभाषित व्यवहार दिखाता है।

आइए पांच स्ट्रिंग्स के साथ 'विभाग' नामक एक खाली वेक्टर बनाएं और पिछले फ़ंक्शन का उपयोग करके अंतिम तत्व को हटा दें। दोनों मामलों में वेक्टर प्रदर्शित करें।

आउटपुट:

'एचआर' अंतिम तत्व है जो 'विभाग' वेक्टर में मौजूद है। तो, इसे वेक्टर से हटा दिया जाता है और अंतिम वेक्टर में 'बिक्री', 'आईटी', 'सेवा' और 'विपणन' होता है।

वेक्टरों को स्वैप करें

वेक्टर::स्वैप() C++ STL में फ़ंक्शन का उपयोग दो वैक्टरों में मौजूद सभी तत्वों को स्वैप करने के लिए किया जाता है।

वाक्य - विन्यास:

यह सदिशों के आकार पर विचार नहीं करता है लेकिन सदिश एक ही प्रकार के होने चाहिए (यदि सदिश प्रकार भिन्न हैं तो त्रुटि उत्पन्न होती है)।

आइए अलग-अलग आकार के स्ट्रिंग प्रकार के दो वेक्टर बनाएं - 'फल' और 'सब्जियां'। उनमें से प्रत्येक को स्वैप करें और दोनों मामलों में वैक्टर प्रदर्शित करें।

आउटपुट:

पहले, 'फल' वेक्टर में दो तत्व होते थे और 'सब्जियां' वेक्टर में तीन तत्व होते थे। अदला-बदली के बाद, 'फल' वेक्टर में तीन तत्व होते हैं और 'सब्जियां' वेक्टर में दो तत्व होते हैं।

वेक्टर से पहला तत्व प्राप्त करें

कुछ मामलों में, वेक्टर से केवल पहला तत्व वापस करने की आवश्यकता होती है। C++ STL में वेक्टर::फ्रंट() फ़ंक्शन वेक्टर से केवल पहला तत्व प्राप्त करता है।

वाक्य - विन्यास:

यह फ़ंक्शन कोई पैरामीटर नहीं लेगा. यदि वेक्टर खाली है, तो एक त्रुटि उत्पन्न होती है।

आइए स्ट्रिंग प्रकार के दो वेक्टर - 'फल' और 'सब्जियां' बनाएं और पहले तत्व को दो वैक्टर से अलग लाने का प्रयास करें।

आउटपुट:

'सेब' पहला तत्व है जो 'फल' वेक्टर में मौजूद है। तो, यह वापस कर दिया जाता है. लेकिन जब हम 'सब्जियां' वेक्टर से पहला तत्व लाने का प्रयास करते हैं तो एक त्रुटि उत्पन्न होती है क्योंकि यह खाली है।

वेक्टर से अंतिम तत्व प्राप्त करें

C++ STL में वेक्टर::end() फ़ंक्शन वेक्टर से केवल अंतिम तत्व प्राप्त करता है।

वाक्य - विन्यास:

यह फ़ंक्शन कोई पैरामीटर नहीं लेगा. यदि वेक्टर खाली है, तो एक त्रुटि उत्पन्न होती है।

आइए स्ट्रिंग प्रकार के दो वेक्टर - 'फल' और 'सब्जियां' बनाएं और अंतिम तत्व को दो वैक्टर से अलग लाने का प्रयास करें।

आउटपुट:

'आम' अंतिम तत्व है जो 'फल' वेक्टर में मौजूद है। तो, यह वापस कर दिया जाता है. लेकिन जब हम 'सब्जियां' वेक्टर से अंतिम तत्व लाने का प्रयास करते हैं तो एक त्रुटि उत्पन्न होती है क्योंकि यह खाली है।

किसी वेक्टर को नए मान निर्दिष्ट करें

कुछ परिदृश्यों में, यदि आप सभी मानों को नए मान के साथ अपडेट करना चाहते हैं या समान मानों के साथ एक वेक्टर बनाना चाहते हैं, तो वेक्टर::असाइन() फ़ंक्शन का उपयोग करना सबसे अच्छा तरीका है। इस फ़ंक्शन का उपयोग करके, हम यह कर सकते हैं:

1. सभी समान तत्वों के साथ वेक्टर बनाएं
2. मौजूदा वेक्टर को उसी तत्व से संशोधित करें

वाक्य - विन्यास:

इस फ़ंक्शन के लिए दो पैरामीटर आवश्यक हैं.

यहाँ:

1. आकार निर्दिष्ट किए जाने वाले तत्वों की संख्या निर्दिष्ट करता है।
2. मान निर्दिष्ट किए जाने वाले तत्व को निर्दिष्ट करता है।

आइए पांच मानों के साथ 'marks1' नामक एक वेक्टर बनाएं और इस वेक्टर को चार तत्वों के साथ अपडेट करें ताकि अपडेट किए गए वेक्टर में सभी तत्व 20 के बराबर हों।

आउटपुट:

पहले, वेक्टर में पांच अलग-अलग तत्व होते थे। अब, इसमें केवल चार तत्व हैं और सभी 20 के बराबर हैं।

Emplace() का उपयोग करके वेक्टर का विस्तार करें

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

वाक्य - विन्यास:

इस फ़ंक्शन में दो अनिवार्य पैरामीटर पास किए गए हैं।

यहाँ:

1. पहला पैरामीटर स्थिति लेता है ताकि हम तत्व को किसी भी स्थिति में सम्मिलित कर सकें। हम शुरुआती() या अंत() इटरेटर फ़ंक्शन का उपयोग करके स्थिति प्राप्त कर सकते हैं।
2. दूसरा पैरामीटर वेक्टर में डाला जाने वाला तत्व है।

दो तत्वों वाले 'रसायन' वेक्टर पर विचार करें।

1. पहले स्थान पर 'मैंगनीज' डालें - प्रारंभ करें (रसायन)
2. अंतिम स्थान पर 'कॉपर' डालें - अंत (रसायन)
3. तीसरे स्थान पर 'सल्फर' डालें - प्रारंभ (रसायन)+2

आउटपुट:

अब, अंतिम वेक्टर में पांच तत्व हैं (निम्नलिखित स्क्रीनशॉट में दिए गए हैं)।

Emplace_Back() का उपयोग करके वेक्टर का विस्तार करें

एक तत्व जोड़ा जा सकता है (वेक्टर के अंत में जोड़कर) जिसे इसका उपयोग करके किया जा सकता है वेक्टर::emplace_back() समारोह।

वाक्य - विन्यास:

वेक्टर में जोड़े जाने वाले तत्व को पैरामीटर के रूप में पास करना अनिवार्य है।

आइए emplace_back() फ़ंक्शन का उपयोग करके एक के बाद एक दो तत्व जोड़ें।

आउटपुट:

अब, अंतिम वेक्टर में 'मैंगनीज' और 'कॉपर' जोड़ने के बाद चार तत्व हैं।

किसी वेक्टर का अधिकतम तत्व

1. कुछ तत्वों के साथ एक वेक्टर बनाएं.
2. वेक्टर में मौजूद अधिकतम तत्व को खोजने के लिए, *max_element() फ़ंक्शन का उपयोग करें जो दो पुनरावृत्तियों को तर्क के रूप में स्वीकार करता है। ये दो पैरामीटर सीमा के रूप में कार्य करते हैं और अधिकतम तत्व प्रदान की गई सीमा के भीतर लौटाया जाता है। प्रारंभिक स्थिति प्रारंभ() है और अंतिम स्थिति अंत() है।

आइए 'आइटम_कॉस्ट' नामक एक वेक्टर पर विचार करें जो पांच पूर्णांक प्रकार के मान रखता है और अधिकतम तत्व लौटाता है।

आउटपुट:

यहां, 8900 उन सभी तत्वों में से अधिकतम तत्व है जो 'आइटम_कॉस्ट' वेक्टर में मौजूद हैं।

वेक्टर का न्यूनतम तत्व

1. कुछ तत्वों के साथ एक वेक्टर बनाएं.
2. वेक्टर में मौजूद न्यूनतम तत्व को खोजने के लिए, *min_element() फ़ंक्शन का उपयोग करें जो दो पुनरावृत्तियों को तर्क के रूप में स्वीकार करता है। ये दो पैरामीटर सीमा के रूप में कार्य करते हैं और न्यूनतम तत्व (अन्य सभी तत्वों से कम) प्रदान की गई सीमा के भीतर लौटा दिया जाता है। प्रारंभिक स्थिति प्रारंभ() है और अंतिम स्थिति अंत() है।

उसी वेक्टर का उपयोग करें जो अधिकतम तत्व को खोजने और *min_element() फ़ंक्शन का उपयोग करके न्यूनतम तत्व को खोजने के लिए बनाया गया है।

आउटपुट:

यहां, 200 उन सभी तत्वों में से न्यूनतम तत्व है जो 'आइटम_कॉस्ट' वेक्टर में मौजूद हैं।

एक वेक्टर में तत्वों का योग

वेक्टर में मौजूद सभी तत्वों का योग वापस करने के लिए जमा करो() C++ STL में फ़ंक्शन का उपयोग किया जाता है। यह तीन मापदंडों को स्वीकार करता है। पहला पैरामीटर पहला इंडेक्स लेता है जो रेंज में शुरुआती तत्व का प्रतिनिधित्व करता है (शुरुआत() इटरेटर निर्दिष्ट करें) और दूसरा पैरामीटर अंतिम इंडेक्स लेता है जो रेंज में अंतिम तत्व का प्रतिनिधित्व करता है (अंत() इटरेटर निर्दिष्ट करें)। अंत में, हमें योग का प्रारंभिक मान पास करना होगा (हमारे मामले में, यह 0 है)।

पांच पूर्णांक प्रकार के तत्वों के साथ 'आइटम_कॉस्ट' नामक एक वेक्टर बनाएं और योग की गणना करें।

आउटपुट:

8900, 5677, 200, 1000, 2300 का योग 18077 है।

दो सदिशों का तत्व-वार गुणन

1. संख्यात्मक प्रकार वाले दो वेक्टर बनाएं और दो वेक्टर एक ही आकार के होने चाहिए (पहले वेक्टर में मौजूद तत्वों की कुल संख्या = दूसरे वेक्टर में मौजूद तत्वों की कुल संख्या)।
2. एक नया वेक्टर घोषित करें और इसका उपयोग करें पाश के लिए , प्रत्येक पुनरावृत्ति में दो तत्वों पर गुणन ऑपरेशन करें, और पुश_बैक() फ़ंक्शन का उपयोग करके मान को बनाए गए वेक्टर में संग्रहीत करें।
के लिए ( int यहाँ आईटीआर = 0 ; मैं < प्रथम_सप्ताह. आकार ( ) ; आईटीआर ++ )

{

परिणाम_वेक्टर. वापस धक्का देना ( प्रथम_सप्ताह [ आईटीआर ] * sec_thing [ आईटीआर ] ) ;

}
3. परिणामी वेक्टर में मौजूद तत्वों को पुनरावृत्त करके प्रदर्शित करें।

पांच पूर्णांक प्रकार के तत्वों के साथ 'आइटम_कॉस्ट' नामक एक वेक्टर बनाएं और योग की गणना करें।

आउटपुट:

दो वेक्टरों का डॉट उत्पाद

C++ वैक्टर के मामले में, डॉट उत्पाद को 'वेक्टर के दो अनुक्रमों की संबंधित प्रविष्टियों के उत्पादों के योग' के रूप में परिभाषित किया गया है।

वाक्य - विन्यास:

डॉट उत्पाद वापस करने के लिए inside_product() फ़ंक्शन का उपयोग करें। यह फ़ंक्शन चार आवश्यक पैरामीटर लेता है.

यहाँ:

1. पहला पैरामीटर एक पुनरावर्तक को संदर्भित करता है जो पहले वेक्टर की शुरुआत को इंगित करता है (begin() फ़ंक्शन का उपयोग करके निर्दिष्ट करें)।
2. दूसरा पैरामीटर एक पुनरावर्तक को संदर्भित करता है जो पहले वेक्टर के अंत को इंगित करता है (अंत() फ़ंक्शन का उपयोग करके निर्दिष्ट करें)।
3. तीसरा पैरामीटर एक पुनरावर्तक को संदर्भित करता है जो दूसरे वेक्टर की शुरुआत को इंगित करता है (begin() फ़ंक्शन का उपयोग करके निर्दिष्ट करें)।
4. प्रारंभिक मान को अंतिम पैरामीटर के रूप में पारित किया जाना है जो डॉट उत्पाद के संचय के लिए एक पूर्णांक है।

उसी प्रोग्राम का उपयोग करें जो दो वैक्टरों के गुणन के लिए बनाया गया है और दो वैक्टरों के डॉट उत्पाद को खोजने के लिए innsr_product() फ़ंक्शन का उपयोग करें।

आउटपुट:

एक सेट को एक वेक्टर में बदलें

किसी सेट में उठाए गए सभी तत्वों को वेक्टर में पास करके किसी सेट को वेक्टर में बदलने के कई तरीके हैं। सबसे अच्छा और सरल तरीका std::copy() फ़ंक्शन का उपयोग करना है।

वाक्य - विन्यास

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

यहाँ:

1. पहला पैरामीटर स्रोत इटरेटर को संदर्भित करता है जो इटरेटर में पहले तत्व को इंगित करता है। यहां, सेट स्रोत इटरेटर है जिसे शुरुआती() फ़ंक्शन का उपयोग करके निर्दिष्ट किया गया है।
2. इसी प्रकार, दूसरा पैरामीटर अंतिम तत्व (एंड() फ़ंक्शन) को इंगित करता है।
3. तीसरा पैरामीटर गंतव्य पुनरावर्तक को संदर्भित करता है जो पुनरावर्तक में पहले तत्व (begin() फ़ंक्शन का उपयोग करके निर्दिष्ट) को इंगित करता है।

आइए पांच छात्रों के साथ एक सेट बनाएं और पिछले फ़ंक्शन का उपयोग करके सभी तत्वों को एक वेक्टर में कॉपी करें।

आउटपुट:

अब, 'स्टूडेंट्स' सेट में मौजूद सभी तत्वों को 'स्टूडेंट्स_वीसी' वेक्टर में कॉपी किया गया है।

डुप्लिकेट तत्वों को हटा दें

1. सबसे पहले, हमें वेक्टर में तत्वों को क्रमबद्ध करने की आवश्यकता है ताकि सभी डुप्लिकेट तत्व एक-दूसरे के निकट हों एसटीडी::सॉर्ट() समारोह।
कक्षा :: क्रम से लगाना ( वेक्टर पहले, वेक्टर अंतिम ) ;
2. std::unique() फ़ंक्शन का उपयोग करें ताकि डुप्लिकेट तत्वों का चयन किया जा सके। साथ ही, std::unique() फ़ंक्शन द्वारा लौटाए गए डुप्लिकेट को हटाने के लिए इरेज़() फ़ंक्शन का उपयोग करें। अंतिम वेक्टर में तत्वों का क्रम बदल सकता है।
वेक्टर। मिटा ( कक्षा :: अद्वितीय ( वेक्टर पहले, वेक्टर अंतिम ) , वेक्टर अंतिम ) )

10 तत्वों के साथ 'छात्र' वेक्टर बनाएं और डुप्लिकेट को हटाकर वेक्टर वापस करें।

आउटपुट:

अब, वेक्टर में सभी तत्व अद्वितीय हैं।

एक वेक्टर को एक सेट में बदलें

सेट डुप्लिकेट तत्वों की अनुमति नहीं देता है। यदि आप डुप्लिकेट वाले सेट में वेक्टर डालने के लिए टाइप कर रहे हैं, तो उन्हें अनदेखा कर दिया जाएगा। हम उसी std::copy() फ़ंक्शन का उपयोग करते हैं जिसका उपयोग पिछले परिदृश्य में किया गया था जिसने सेट को वेक्टर में बदल दिया था।

इस परिदृश्य में:

1. पहला पैरामीटर वेक्टर को स्रोत पुनरावर्तक के रूप में लेता है जिसे शुरुआती() फ़ंक्शन का उपयोग करके निर्दिष्ट किया जाता है।
2. दूसरा पैरामीटर वेक्टर को स्रोत इटरेटर के रूप में लेता है जिसे एंड() फ़ंक्शन का उपयोग करके निर्दिष्ट किया जाता है।
3. std::inserter() फ़ंक्शन को पास करें जिसका उपयोग पैरामीटर के रूप में सेट के अंत तक इंगित करने वाले सेट और इटरेटर को प्रदान करके सेट में एक विशिष्ट स्थान पर तत्वों को स्वचालित रूप से ओवरराइट/कॉपी करने के लिए किया जाता है।

आइए 10 पूर्णांकों वाला एक वेक्टर बनाएं और तत्वों को एक सेट में कॉपी करें।

आउटपुट:

'मार्क्स' नाम के मौजूदा वेक्टर में 10 मान हैं। इसे 'marks_set' सेट में कॉपी करने के बाद, इसमें केवल छह तत्व होते हैं क्योंकि अन्य चार तत्व डुप्लिकेट होते हैं।

खाली स्ट्रिंग्स हटाएँ

वेक्टर में मौजूद खाली स्ट्रिंग्स का कोई उपयोग नहीं है। वेक्टर में मौजूद खाली स्ट्रिंग्स को हटाना एक अच्छा अभ्यास है। आइए देखें कि C++ वेक्टर से खाली स्ट्रिंग्स को कैसे हटाया जाए:

1. 'फॉर' लूप का उपयोग करके वेक्टर को पुनरावृत्त करें।
2. प्रत्येक पुनरावृत्ति में, जांचें कि क्या तत्व खाली है ('') या at() सदस्य फ़ंक्शन के साथ '==' ऑपरेटर का उपयोग नहीं कर रहा है।
3. std::erase() फ़ंक्शन का उपयोग करके, पिछली स्थिति की जाँच करने के बाद खाली स्ट्रिंग्स को हटा दें।
4. वेक्टर के अंत तक चरण 2 और चरण 3 को दोहराएं।

आइए 10 स्ट्रिंग्स के साथ 'कंपनियां' वेक्टर बनाएं। उनमें से पांच खाली हैं और हम पिछले दृष्टिकोण को लागू करके उन्हें हटा देते हैं।

आउटपुट:

अब, 'कंपनी' वेक्टर गैर-रिक्त स्ट्रिंग रखता है।

किसी टेक्स्ट फ़ाइल में एक वेक्टर लिखें

आइए चर्चा करें कि वेक्टर सूचकांकों का उपयोग करके वेक्टर में मौजूद सभी तत्वों को फ़ाइल में कैसे लिखा जाए fstream .

1. वेक्टर को आरंभ करने के बाद पुश_बैक फ़ंक्शन का उपयोग करके इसमें कुछ तत्व पुश करें।
2. मोड आउट के साथ 'एफस्ट्रीम' लाइब्रेरी से ओपन() फ़ंक्शन का उपयोग करें।
3. वेक्टर में मौजूद प्रत्येक तत्व को 'फॉर' लूप में सूचकांकों का उपयोग करके ट्रैवर्स करें और प्रत्येक तत्व को प्रदान की गई फ़ाइल में लिखें।
4. अंत में, फ़ाइल बंद करें।

आइए C++ कोड चलाकर पिछले दृष्टिकोण को लागू करें।

आउटपुट:

'v_data' वेक्टर में दो तत्व होते हैं और पथ में एक फ़ाइल बनाई जाती है जहां प्रोग्राम को वेक्टर में मौजूद तत्वों के साथ निष्पादित किया जाता है।

टेक्स्ट फ़ाइल से एक वेक्टर बनाएं

हमने सीखा कि वेक्टर में मौजूद तत्वों को टेक्स्ट फ़ाइल में कैसे लिखा जाता है। यहां, आइए टेक्स्ट फ़ाइल में मौजूद सामग्री से एक वेक्टर बनाएं।

1. एक बनाएं ' इफस्ट्रीम' वेरिएबल जिसका उपयोग टेक्स्ट फ़ाइल से जानकारी पढ़ने के लिए किया जाता है जिसमें हम फ़ाइल से वेक्टर बनाते हैं।
2. फ़ाइल सामग्री को संग्रहीत करने के लिए एक खाली वेक्टर बनाएं और फ़ाइल के अंत की जांच करने के लिए ध्वज के रूप में एक खाली स्ट्रिंग वैरिएबल का उपयोग करें।
3. फ़ाइल की अगली पंक्ति तब तक पढ़ें जब तक वह अंत तक न पहुँच जाए (मूल रूप से 'जबकि' लूप का उपयोग करके)। अगली पंक्ति को पढ़ने और उसे वेक्टर में धकेलने के लिए पुश_बैक() फ़ंक्शन का उपयोग करें।
4. कंसोल पर वेक्टर में मौजूद तत्वों को देखने के लिए लाइन में मौजूद लाइन को अलग से प्रदर्शित करें।

आइए C++ कोड चलाकर पिछले दृष्टिकोण को लागू करें। आइए निम्नलिखित सामग्री वाली 'data.txt' फ़ाइल पर विचार करें। यहाँ, वेक्टर का नाम 'v_data' है।

आउटपुट:

हम देख सकते हैं कि 'v_data' में फ़ाइल से आए पांच तत्व हैं।

निष्कर्ष

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