मेन्यू

वैक्टर इन एसटीएल

vectors stl

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

उदाहरणों में STL में वैक्टर की भूमिका।

अब तक, इस सी ++ श्रृंखला में, हमने स्थिर सरणियों को देखा है जिनका एक निश्चित आकार है।

यदि प्रोग्राम के मध्य में हमें ऐरे में अधिक तत्वों को स्टोर करना है, तो यह असंभव हो जाता है और हमें bound out_of_bound ’अपवाद मिलना सुनिश्चित होता है, जिस क्षण हम ऐरे लिमिट से परे एलीमेंट्स स्टोर करने का प्रयास करते हैं।

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

=> पूर्ण सी ++ प्रशिक्षण श्रृंखला यहां देखें।

STL में वेक्टर्स

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

आप क्या सीखेंगे:

हम सेक्टरों को कैसे परिभाषित करते हैं?

वैक्टर डायनेमिक एरे कंटेनर होते हैं जो तत्वों के डालने या हटाए जाने पर इसे स्वचालित रूप से आकार देते हैं। वेक्टर का भंडारण स्वयं वेक्टर कंटेनर द्वारा नियंत्रित किया जाता है।

वेक्टर में तत्व सन्निहित स्थानों में संग्रहीत किए जाते हैं। सरणियों की तरह, वेक्टर तत्वों को भी पुनरावृत्त किया जा सकता है और पुनरावृत्तियों का उपयोग किया जा सकता है।

C ++ के साथ C वेक्टर में एक वेक्टर की घोषणा :: वेक्टर वर्ग

एसटीएल वेक्टर वर्ग में ‘ एसटीडी :: वेक्टर 'हेडर के तहत परिभाषित किया गया है। इस प्रकार, एक वेक्टर कंटेनर का उपयोग करने के लिए, हमें इस कार्यक्रम को अपने कार्यक्रम में शामिल करना चाहिए जैसा कि नीचे दिखाया गया है:

#include

हम नीचे दिखाए गए अनुसार एक खाली वेक्टर घोषित कर सकते हैं:

std::vector myvec;

कोड की उपरोक्त पंक्ति प्रकार पूर्णांक के तत्वों के साथ एक वेक्टर बनाएगी। स्मृति में, इसे myvec के रूप में रखा जाएगा।

वेक्टर को इनिशियलाइज़ करें

हम एक वेक्टर को घोषित करने के समय मूल्य के साथ आरंभ कर सकते हैं।

Android के लिए सबसे अच्छा मुफ्त संगीत डाउनलोडर क्या है

यह अग्रानुसार होगा:

#include int main() { std::vector myvec = {1, 1, 2, 3, 5}; }

उपर्युक्त कोड में, हम एक वेक्टर के प्रकार को घोषित करते हैं जिसका नाम myvec होता है जिसमें फिबोनाची अनुक्रम में पहले पांच तत्व होते हैं।

इस वेक्टर का मेमोरी लेआउट निम्नानुसार होगा:

वेक्टर का मेमोरी लेआउट

वेक्टर Iterator

जैसा कि पहले ही उल्लेख किया गया है, हम वेक्टर क्रमिक रूप से पार करने के लिए पुनरावृत्तियों का उपयोग करते हैं।

तत्वों के माध्यम से कदम रखने के लिए वैक्टर निम्नलिखित पुनरावृत्ति कार्यों का समर्थन करते हैं:

  • शुरू() - वेक्टर कंटेनर के पहले तत्व को इंगित रिटर्न इट्रेटर।
  • समाप्त() - वेक्टर में अंतिम तत्व का अनुसरण करने वाले तत्व की ओर इशारा करते हुए एक पुनरावृत्ति देता है।
  • रेबेगिन () - वेक्टर कंटेनर में अंतिम तत्व की ओर इशारा करते हुए एक रिवर्स इटेटर लौटाता है।
  • प्रस्तुत करना () - वेक्टर कंटेनर के पहले तत्व की ओर इशारा करते हुए एक रिवर्स इटरेटर लौटाता है।
  • केबीन () - वेक्टर कंटेनर में पहले तत्व की ओर इशारा करते हुए एक निरंतर पुनरावृत्ति देता है।
  • कुछ() - वेक्टर कंटेनर के अंतिम तत्व का अनुसरण करते हुए तत्व की ओर इशारा करते हुए एक निरंतर पुनरावृत्ति देता है।
  • crbegin () - वेक्टर कंटेनर में अंतिम तत्व की ओर इशारा करते हुए एक निरंतर स्थिर पुनरावृत्ति देता है।
  • crend ​​() - वेक्टर कंटेनर में पहले तत्व की ओर इशारा करते हुए एक निरंतर स्थिर पुनरावृत्ति देता है।

आइए एक उदाहरण देखें जो इन पुनरावृत्त कार्यों को प्रदर्शित करेगा।अन्य कार्यों का उपयोग इसी तरह किया जा सकता है।

#include #include using namespace std; int main() { vector v1; for (int i = 1; i <= 5; i++) v1.push_back(i+1); cout << 'Output of Vector with begin and end: '; for (auto i = v1.begin(); i != v1.end(); ++i) cout << *i << ' '; cout << ' Output of Vector with rbegin and rend: '; for (auto itr = v1.rbegin(); itr != v1.rend(); ++itr) cout << *itr << ' '; cout << ' Output Vector of with cbegin and cend: '; for (auto itc = v1.cbegin(); itc != v1.cend(); ++itc) cout << *itc << ' '; cout << ' Output Vector of with crbegin and crend : '; for (auto icr = v1.crbegin(); icr != v1.crend(); ++icr) cout << *icr << ' '; return 0; }

आउटपुट:

शुरुआत और अंत के साथ वेक्टर का आउटपुट: 2 3 4 5 6
रेबेगिन और प्रतिपादन के साथ वेक्टर का आउटपुट: 6 5 4 3 2
Cbegin और cend के साथ आउटपुट वेक्टर: 2 3 4 5 6
क्रैबिन और क्रेंड के साथ आउटपुट वेक्टर: 6 5 4 3 2

इस प्रकार इस कोड में, हम पुश_बैक फ़ंक्शन का उपयोग करके एक वेक्टर घोषित करते हैं और उसमें मान डालते हैं। फिर हम प्रत्येक इटेटर फ़ंक्शंस का उपयोग करके वैक्टर को प्रदर्शित करते हैं जो हमने ऊपर वर्णित किया था। जैसा कि आप आउटपुट से उपयोग किए जाने वाले इटेटर कार्यों के आधार पर देखते हैं, जिस क्रम में वेक्टर प्रदर्शित होता है।

वेक्टर कार्य

एक सदिश छँटाई

हम एसटीएल एल्गोरिदम का उपयोग कर सकते हैं जो हम पहले ही वेक्टर पर देख चुके हैं।

नीचे दिए गए वेक्टर पर 'सॉर्ट' का उपयोग करने का उदाहरण है।

#include #include #include using namespace std; int main() { vector myvec = {10,50,30,20,60,40}; cout<<'Original Vector'<

आउटपुट:

मूल वेक्टर
10 50 30 20 60 40
क्रमबद्ध वेक्टर
10 20 30 40 50 60

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

एक वेक्टर के मुद्रण तत्व

इट्रेटर और 'कॉउट' स्ट्रीम का उपयोग करके वैक्टर मुद्रित किया जा सकता है। हम वेक्टर तत्वों में से प्रत्येक के माध्यम से कदम रखने और cout के साथ उन्हें मुद्रित करने के लिए एक पुनरावृत्ति का उपयोग कर सकते हैं।

निम्न उदाहरण यह दिखाता है:

#include #include using namespace std; int main() { vector v1; for (int i = 1; i <= 5; i++) v1.push_back(i+2); cout << 'Output of Vector with begin and end: '; for (auto i = v1.begin(); i != v1.end(); ++i) cout << *i << ' '; }

आउटपुट:

आरंभ और अंत के साथ वेक्टर का आउटपुट: 3 4 5 6 7

वेक्टर क्षमता

विभिन्न कार्य हैं जो वैक्टर पर कार्य करते हैं ताकि इसके आकार, अधिकतम आकार आदि का निर्धारण किया जा सके।

हम नीचे दिए गए कार्यों को सूचीबद्ध करते हैं:

(i) वेक्टर का आकार

फ़ंक्शन आकार () वेक्टर कंटेनर में तत्वों की संख्या लौटाता है। यह std :: वेक्टर वर्ग का इन-बिल्ट फ़ंक्शन है और वेक्टर के आकार को खोजने के लिए इसका सीधा उपयोग किया जा सकता है।

1 साल के अनुभव के लिए php साक्षात्कार प्रश्न और उत्तर

आइए हम आकार () फ़ंक्शन का उपयोग करके वेक्टर का एक उदाहरण देखते हैं:

#include #include using namespace std; int main() { vector myvec = {1, 1, 2, 3, 5, 8}; cout << 'Vector Size : ' << myvec.size(); return 0; }

आउटपुट:

वेक्टर का आकार: 6

उपरोक्त कार्यक्रम में, हमने एक वेक्टर myvec को परिभाषित किया है जिसमें छह तत्व शामिल हैं। अगला, हम myvec पर आकार () फ़ंक्शन कहते हैं और यह सही आकार प्रदर्शित करता है।

(ii) वेक्टर का आकार बदलना

हम एक वेक्टर को वांछित आकार में भी बदल सकते हैं, ताकि वह तत्वों की संख्या को पकड़ सके। यह std :: वेक्टर वर्ग के 'आकार ()' फ़ंक्शन द्वारा प्राप्त किया जाता है। आकार बदलने का कार्य वेक्टर के आकार को पैरामीटर के रूप में लेता है और फिर वेक्टर कंटेनर को निर्दिष्ट आकार में बदलता है।

इसे एक उदाहरण की मदद से समझते हैं।

#include #include using namespace std; int main() { vector myvec = {1, 1, 2, 3, 5, 8}; cout << ' Vector elements are: '; for (auto it = myvec.begin(); it != myvec.end(); it++) cout << *it << ' '; myvec.resize(4); cout << ' Vector Size after resize: ' << myvec.size(); cout << ' Vector elements after resizing are: '; for (auto it = myvec.begin(); it != myvec.end(); it++) cout << *it << ' '; return 0; }

आउटपुट:

वेक्टर तत्व हैं: 1 1 2 3 5 8
आकार आकार के बाद आकार: 4
आकार देने के बाद वेक्टर तत्व हैं: 1 1 2 3

उपरोक्त कार्यक्रम में, हम शुरू में आकार के एक वेक्टर myvec 6 को परिभाषित करते हैं। फिर हम इस वेक्टर पर आकार = 4 के साथ आकार फ़ंक्शन को कहते हैं। इसका मतलब है कि हम अपने वेक्टर को आकार 4 में बदलना चाहते हैं।

आकार बदलने वाले फ़ंक्शन को कॉल करने के बाद हम वेक्टर को फिर से प्रिंट करते हैं। हम देखते हैं कि जब हम वेक्टर को आकार 4 में आकार देते हैं, तो शेष तत्वों को छोड़ दिया जाता है और वेक्टर के केवल 4 तत्वों को प्रदर्शित किया जाता है।

आकार और कार्यों के आकार के अलावा, वेक्टर वर्ग कुछ और कार्यों का भी समर्थन करता है जो हमें वेक्टर की क्षमता में हेरफेर करने की अनुमति देते हैं। वे:

  • अधिकतम आकार(): अधिकतम आकार लौटाता है यानि वेक्टर की अधिकतम संख्या पकड़ सकती है।
  • क्षमता(): वर्तमान में आवंटित संग्रहण स्थान का आकार लौटाता है। यह तत्वों की संख्या के संदर्भ में वापस किया जाता है।
  • खाली (): जाँचता है कि कंटेनर खाली है या नहीं।
  • जमा करने के लिए हटना(): आकार फिट करने के लिए वेक्टर क्षमता को सिकोड़ता है और अन्य सभी तत्वों को त्यागता है।
  • रिजर्व (): एन तत्वों को शामिल करने के लिए वेक्टर क्षमता को आरक्षित करता है।

वेक्टर संशोधक

संशोधक ऑपरेशन या फ़ंक्शन हैं जिनका उपयोग वेक्टर कंटेनर की सामग्री को संशोधित करने के लिए किया जा सकता है। हम कुछ मुख्य कार्य देखेंगे जिन्हें संशोधक के रूप में उपयोग किया जाता है।

वेक्टर के लिए नए मान असाइन करना

Std :: वेक्टर द्वारा प्रदान किए गए संशोधक कार्यों में से एक कार्य फ़ंक्शन है। असाइन फ़ंक्शन पुराने वाले को बदलकर वेक्टर को नए मान प्रदान करता है।

यह निम्नलिखित उदाहरण में दिखाया गया है।

#include #include using namespace std; int main() { // Assign vector vector myvec; // assign value 10 5 times myvec.assign(5, 10); cout << 'The vector elements: '; for (int i = 0; i < myvec.size(); i++) cout << myvec(i) << ' '; }

आउटपुट:

वेक्टर तत्व: 10 10 10 10 10

उपरोक्त कोड में, हम एक वेक्टर को टाइप इंट घोषित करते हैं। फिर हम पैरामीटर 5 के साथ एक फ़ंक्शन असाइन करने के लिए कॉल करते हैं। 10. इसका मतलब है कि हम 5 बार वेक्टर को तत्व 10 असाइन करना चाहते हैं। जब हम वेक्टर प्रदर्शित करते हैं, तो हम देखते हैं कि वेक्टर में 5 तत्व हैं, सभी मूल्य 5 के साथ हैं।

एक वेक्टर को मिटाते हुए

एसटीडी द्वारा प्रदान किया गया अगला फ़ंक्शन :: वेक्टर को संशोधित करने के लिए वेक्टर 'इरेज़' फ़ंक्शन है। मिटाएँ फ़ंक्शन निर्दिष्ट श्रेणी या वेक्टर से स्थिति से तत्वों को निकालता है।

आइए हम Erase फ़ंक्शन का एक उदाहरण देखते हैं।

#include #include using namespace std; int main() { // Initialize vector vector myvec = {1,1,2,3,5}; cout << ' Vector elements:'; for (int i = 0; i < myvec.size(); i++) cout << myvec(i) << ' '; // remove the first element myvec.erase(myvec.begin()); cout<<' Vector size after erase: '<

आउटपुट:

वेक्टर तत्व: 1 1 2 3 5

मिटाने के बाद वेक्टर का आकार: 4
मिटा ऑपरेशन के बाद वेक्टर: 1 2 3 5

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

वेक्टर में तत्वों को सम्मिलित करें

वेक्टर क्लास std :: वेक्टर वेक्टर में मान डालने के लिए एक और फ़ंक्शन प्रदान करता है। डालें फ़ंक्शन हमें निर्दिष्ट स्थिति से पहले वेक्टर में तत्वों को सम्मिलित करने की अनुमति देता है।

यह निम्नलिखित उदाहरण से स्पष्ट होगा।

#include #include using namespace std; int main() { // Assign vector vector myvec = {2,3,4}; cout << ' Initial vector: '; for (int i = 0; i < myvec.size(); i++) cout << myvec(i) << ' '; // inserts 20 at the beginning, 30 after that myvec.insert(myvec.begin(), 20); myvec.insert(myvec.begin()+1,30); cout << ' New vector after insert: '; for (int i = 0; i < myvec.size(); i++) cout << myvec(i) << ' '; }

आउटपुट:

प्रारंभिक वेक्टर: 2 3 4

डालने के बाद नया वेक्टर: 20 30 2 3 4

उपरोक्त कार्यक्रम शुरू में 3 तत्वों के साथ एक वेक्टर घोषित करता है। फिर हम वेक्टर में पहले और दूसरे स्थान पर मान 20 और 30 डालने के लिए दो बार डालने का कार्य कहते हैं। फिर हम बदले हुए वेक्टर को प्रदर्शित करते हैं।

वेक्टर सामग्री की अदला-बदली

वेक्टर वर्ग हमें एक ही वेक्टर के एक ही प्रकार और आकार के साथ एक वेक्टर की सामग्री को स्वैप या विनिमय करने की क्षमता प्रदान करता है। इसे वेक्टर बिल्ट-इन फंक्शन achieved स्वैप ’द्वारा हासिल किया गया है।

निम्नलिखित कोड पर विचार करें।

#include #include using namespace std; int main() { // swap operation vector v1, v2; v1.push_back(1); v1.push_back(3); v2.push_back(5); v2.push_back(7); cout << ' Vector 1: '; for (int i = 0; i < v1.size(); i++) cout << v1(i) << ' '; cout << ' Vector 2: '; for (int i = 0; i < v2.size(); i++) cout << v2(i) << ' '; // Swaps v1 and v2 v1.swap(v2); cout << ' After Swap Vector 1: '; for (int i = 0; i < v1.size(); i++) cout << v1(i) << ' '; cout << ' Vector 2: '; for (int i = 0; i < v2.size(); i++) cout << v2(i) << ' '; }

आउटपुट:

वेक्टर 1: 1 3
वेक्टर 2: 5 7
स्वैप के बाद
वेक्टर 1: 5 7
वेक्टर 2: 1 3

उपरोक्त कोड स्वैप करने से पहले और बाद में दो वैक्टर की सामग्री को दर्शाता है।

वेक्टर में समाशोधन मान

मिटा फ़ंक्शन का उपयोग करके वेक्टर से एक या एक से अधिक तत्वों को हटाने के विपरीत, हमारे पास एक और फ़ंक्शन ’Clear’ है जो हमें वेक्टर कंटेनर में सभी तत्वों को निकालने की अनुमति देता है।

नीचे दिए गए कार्यक्रम में, हम वेक्टर कंटेनर के एक स्पष्ट कार्य को प्रदर्शित करते हैं।

#include #include using namespace std; int main() { // swap operation vector v1; v1.push_back(1); v1.push_back(3); v1.push_back(5); v1.push_back(7); cout<<' Size of vector v1: '<

आउटपुट:

वेक्टर v1 का आकार: 4
वेक्टर 1: 1 3 5 7
वेक्टर v1 का आकार स्पष्ट करने के लिए कॉल के बाद: 0

यहां हम पहले एक वेक्टर घोषित करते हैं और फिर उसमें तत्वों को धकेलते हैं। एक बार जब हम फ़ंक्शन को स्पष्ट () कहते हैं, तो हम देखते हैं कि वेक्टर के सभी तत्व एक ही बार में हटा दिए जाते हैं।

(स्थिति)

यह फ़ंक्शन वेक्टर के भीतर स्थिति 'स्थिति' के तत्व का संदर्भ देता है।

यह उन कार्यों में से एक है जिसका उपयोग वेक्टर तत्व तक पहुंचने के लिए किया जाता है।

एक उदाहरण नीचे दिया गया है:

#include #include using namespace std; int main() { // Assign vector vector myvec = {1,1,2,3,5,8}; cout<<' Element at position 3 : '<

आउटपुट:

स्थिति 3: 3 पर तत्व

जैसा कि उदाहरण में दिखाया गया है,। At ’फ़ंक्शन का उपयोग वेक्टर में तत्व को निर्दिष्ट स्थान पर एक्सेस करने के लिए किया जाता है।

सामने

फ़ंक्शन 'फ्रंट' वेक्टर के पहले तत्व का संदर्भ देता है। यह अभी तक एक और फ़ंक्शन है जिसका उपयोग हम वेक्टर कंटेनर के तत्वों तक पहुंचने के लिए करते हैं।

निम्न उदाहरण में 'सामने' फ़ंक्शन का उपयोग दिखाया गया है।

#include #include #include using namespace std; int main() { // Initialize vector vector myvec = {1,1,2,3,5,8}; cout<<' Input vector: '; for(auto it=myvec.begin();it

आउटपुट:

इनपुट वेक्टर: 1 1 2 3 5 8
वेक्टर के सामने तत्व: 1

वापस

To फ्रंट ’फ़ंक्शन के समान, वेक्टर कंटेनर के अंतिम तत्व तक पहुंचने के लिए बैक फ़ंक्शन का उपयोग किया जाता है। 'बैक' फ़ंक्शन वेक्टर कंटेनर में अंतिम तत्व का संदर्भ देता है।

sql प्रश्न और उत्तर पीडीएफ़ प्रश्न

निम्न उदाहरण 'बैक' फ़ंक्शन के उपयोग को दर्शाता है।

#include #include #include using namespace std; int main() { // Initialize vector vector myvec = {1,1,2,3,5,8}; cout<<' Input vector: '; for(auto it=myvec.begin();it

आउटपुट:

इनपुट वेक्टर: 1 1 2 3 5 8
वेक्टर के पीछे तत्व: 8

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

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

निम्न उदाहरण खोज फ़ंक्शन के उपयोग को दर्शाता है।

#include #include #include using namespace std; int main() { // Assign vector vector myvec = {1,1,2,3,5,8}; cout<<' Input vector: '; for(auto it=myvec.begin();itkey; if(find(myvec.begin(),myvec.end(),key)!= myvec.end()) cout<<' Element found'; else cout<<' Element not found'; }

आउटपुट:

इनपुट वेक्टर: 1 1 2 3 5 8
खोज की जाने वाली कुंजी दर्ज करें: 0

तत्व नहीं मिला

2 डी वेक्टर

द्वि-आयामी वेक्टर को vector वेक्टर का वेक्टर ”के रूप में भी जाना जाता है। द्वि-आयामी सरणियों की तरह, मैट्रिक्स के रूप में दो-आयामी वैक्टर के तत्वों को भी व्यवस्थित किया जाता है।

2D वेक्टर के लिए एक उदाहरण कार्यक्रम नीचे दिया गया है।

#include #include // for 2D vector using namespace std; int main() { // Initializing 2D vector 'odd_vect' with vector odd_vect{ { 1, 3, 5 }, { 7, 9, 11 }, { 13,15,17 } }; // Displaying the 2D vector cout<<'2D vector : '; cout<

आउटपुट:

2D वेक्टर:
1 3 5
९ ११
१३ १५ १ 17

उपरोक्त उदाहरण में, जिस तरह से 2 डी वेक्टर परिभाषित किया गया है, उस पर ध्यान दें। इसे दूसरे वेक्टर के अंदर एक वेक्टर के रूप में परिभाषित किया गया है। इस 2D वेक्टर को प्रदर्शित करते समय, हम उसी दृष्टिकोण का उपयोग करते हैं, जो 2D सरणियों को प्रदर्शित करते हैं।

वेक्टर उदाहरण

नीचे दिया गया एक वेक्टर उदाहरण है जिसमें अधिकांश वेक्टर ऑपरेशन शामिल हैं।

#include #include using namespace std; int main() { // Assign vector vector myvec; // assign value 10 5 times myvec.assign(5, 10); cout << 'The vector elements: '; for (int i = 0; i < myvec.size(); i++) cout << myvec(i) << ' '; // push value 5 in myvec myvec.push_back(5); int n = myvec.size(); cout << ' The new vector after push_back:'; for (int i = 0; i < myvec.size(); i++) cout << myvec(i) << ' '; // pop the element myvec.pop_back(); cout<<' New vector after pop_back : '; for (int i = 0; i < myvec.size(); i++) cout << myvec(i) << ' '; // inserts 20 at the beginning myvec.insert(myvec.begin(), 20); cout << ' New vector after insert: '; for (int i = 0; i < myvec.size(); i++) cout << myvec(i) << ' '; // remove the first element myvec.erase(myvec.begin()); cout<<' Vector size after erase: '<

आउटपुट:

वेक्टर तत्व: 10 10 10 10 10
पुश_बैक के बाद नया वेक्टर: 10 10 10 10 10 5
Pop_back के बाद नया वेक्टर: 10 10 10 10 10
डालने के बाद नया वेक्टर: 20 10 10 10 10 10
मिटाने के बाद वेक्टर का आकार: 5
पहले तत्व को मिटाने के बाद: 10 10 10 10 10

निम्नलिखित उसी के लिए स्क्रीनशॉट है।

वेक्टर उदाहरण आउटपुट

उपरोक्त उदाहरण में, हम एक वेक्टर घोषित करते हैं और फिर असाइन और पुश_बैक फ़ंक्शंस का उपयोग करते हुए वेक्टर में तत्वों को दर्ज करते हैं। फिर हम वेक्टर के अंत से एक तत्व को हटाने के लिए फ़ंक्शन pop_back का उपयोग करते हैं। उसके बाद, हम फिर से सम्मिलित तत्व का उपयोग करके वेक्टर में एक तत्व जोड़ते हैं और फिर मिटा फ़ंक्शन का उपयोग करके तत्व को मिटा देते हैं।

यह वेक्टर कंटेनर के अंत-से-अंत का उदाहरण है जो अपने विभिन्न कार्यों का प्रदर्शन करता है।

निष्कर्ष

इसके साथ, हम वेक्टर पर इस ट्यूटोरियल के अंत में आ गए हैं।

हमारे आगामी ट्यूटोरियल में, हम एसटीएल के container सूची 'कंटेनर के बारे में जानेंगे जो सरणियों और वैक्टरों की पंक्तियों के समान है।

=> यहां परफेक्ट सी ++ ट्रेनिंग गाइड देखें।

अनुशंसित पाठ

^