C++ वेक्टर का उपयोग कैसे करें

How Use C Vector



परिचय

एक सरणी लगातार स्मृति स्थानों में समान ऑब्जेक्ट प्रकारों की एक श्रृंखला है। एक सरणी लंबाई में अयस्क को कम नहीं कर सकती है। एक वेक्टर एक सरणी की तरह है, लेकिन इसकी लंबाई को बढ़ाया या घटाया जा सकता है। इसलिए, एक वेक्टर में एक सरणी की तुलना में कई अधिक ऑपरेशन होते हैं।

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







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



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



यह आलेख आपको दिखाता है कि C++ वेक्टर का उपयोग कैसे करें। इस लेख को समझने के लिए आपको C++ पॉइंटर्स, संदर्भों और सरणियों के कुछ ज्ञान की आवश्यकता होगी।





वर्ग और वस्तुएं

एक वर्ग चर और कार्यों का एक समूह है जो एक साथ काम करते हैं, जहां चर के पास मान निर्दिष्ट नहीं होते हैं। जब वेरिएबल को मान असाइन किए जाते हैं, तो एक वर्ग एक ऑब्जेक्ट बन जाता है। एक ही वर्ग को दिए गए विभिन्न मूल्यों का परिणाम अलग-अलग वस्तुओं में होता है; यानी अलग-अलग वस्तुएं एक ही वर्ग की हो सकती हैं लेकिन उनके अलग-अलग मूल्य हो सकते हैं। किसी वर्ग से ऑब्जेक्ट बनाना ऑब्जेक्ट को इंस्टेंट करना भी कहा जाता है।

वेक्टर शब्द एक वर्ग का वर्णन करता है। वेक्टर से बनाई गई वस्तु का एक नाम होता है जिसे प्रोग्रामर द्वारा चुना जाता है।



एक वर्ग से संबंधित एक फ़ंक्शन को कक्षा से किसी वस्तु को तुरंत चालू करने की आवश्यकता होती है। सी ++ में, उस फ़ंक्शन का नाम वर्ग के नाम के समान होता है। कक्षा से बनाई गई (तत्काल) विभिन्न वस्तुओं में प्रोग्रामर द्वारा उनमें से प्रत्येक को अलग-अलग नाम दिए गए हैं।

एक वर्ग से एक वस्तु बनाने का अर्थ है वस्तु का निर्माण करना; इसका अर्थ वस्तु को तत्काल करना भी है।

वेक्टर वर्ग

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

#शामिल

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

#शामिल
#शामिल

वेक्टर को इंस्टेंट करना

NSफू[10];

ऊपर foo नाम और तत्वों की संख्या 10 के साथ एक सरणी की घोषणा है। यह पूर्णांकों की एक सरणी है। वेक्टर की घोषणा समान है। एक वेक्टर के लिए, तत्वों की संख्या वैकल्पिक है, क्योंकि वेक्टर की लंबाई बढ़ या घट सकती है।

कार्यक्रम में इस बिंदु पर, वेक्टर वर्ग को पहले से ही पुस्तकालय में परिभाषित किया गया है, और हेडर को शामिल किया गया है। वेक्टर को निम्नानुसार त्वरित किया जा सकता है:

घंटे::वेक्टर <NS>वीटीआर(8);

यहां, वेक्टर विशेष कंस्ट्रक्टर फ़ंक्शन का है। वेक्टर जिस प्रकार का डेटा रखेगा, वह कोण कोष्ठक में int है। वीटीआर शब्द प्रोग्रामर द्वारा वेक्टर के लिए चुना गया नाम है। अंत में, 8, कोष्ठकों में, सदिश के पास पूर्णांकों की अस्थायी संख्या है।

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

#शामिल
#शामिल
नेमस्पेस एसटीडी का उपयोग करना;

किसी फ़ंक्शन को ओवरलोड करना

जब दो या दो से अधिक भिन्न फ़ंक्शन हस्ताक्षरों का एक ही नाम होता है, तो उस नाम को अतिभारित कहा जाता है। जब एक फ़ंक्शन को कॉल किया जाता है, तो संख्या और प्रकार के तर्क निर्धारित करते हैं कि कौन सा फ़ंक्शन निष्पादित किया गया है।

एक वेक्टर का निर्माण

सदिश का निर्माण करने का अर्थ है एक सदिश वस्तु को तत्काल बनाना (बनाना)। कंस्ट्रक्टर फ़ंक्शन निम्नानुसार अतिभारित है:

वेक्टर नाम

यह लंबाई शून्य का वेक्टर बनाता है और टी टाइप करता है। निम्न कथन vtr नाम के साथ फ्लोट प्रकार की शून्य लंबाई का वेक्टर बनाता है:

वेक्टर<पानी पर तैरना>वीटीआर;

वेक्टर नाम (एन)

यह टाइप टी के n तत्वों के साथ एक वेक्टर बनाता है। इस वेक्टर के लिए चार फ्लोट तत्वों के साथ एक बयान इस प्रकार है:

वेक्टर<पानी पर तैरना>वीटीआर(4);

वेक्टर नाम (एन, टी)

यह मान t से आरंभिक n तत्वों का एक वेक्टर बनाता है। निम्नलिखित कथन 5 तत्वों का एक सदिश बनाता है, जहाँ प्रत्येक तत्व का मान 3.4 है:

वेक्टर<पानी पर तैरना>वीटीआर(5, ३.४);

आरंभीकरण के साथ निर्माण

एक वेक्टर का निर्माण (बनाया) और एक ही समय में, निम्नलिखित दो तरीकों में से एक में किया जा सकता है:

वेक्टर<पानी पर तैरना>वीटीआर= {१.१, २.२, 3.3, 4.4};

या

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};

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

वेक्टर<पानी पर तैरना>वीटीआर({१.१, २.२, 3.3, 4.4});

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

वेक्टर<पानी पर तैरना>वीटीआर;
वीटीआर= {१.१, २.२, 3.3, 4.4};

वेक्टर V2 (V1)

यह एक कॉपी कंस्ट्रक्टर है। यह वेक्टर V1 की एक प्रति के रूप में एक वेक्टर V2 बनाता है। निम्नलिखित कोड इसे दिखाता है:

वेक्टर<पानी पर तैरना>vtr1(5, ३.४);
वेक्टर<पानी पर तैरना>vtr2(vtr1);

निर्माण के दौरान एक वेक्टर असाइन करना

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

वेक्टर<पानी पर तैरना>vtr1{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना>vtr2=vtr1;

दूसरा कथन इसके बराबर है:

वेक्टर<पानी पर तैरना>vtr2= {१.१, २.२, 3.3, 4.4};

स्थिरांक वेक्टर

एक कॉन्स वेक्टर एक वेक्टर है जिसके तत्वों को बदला नहीं जा सकता है। इस वेक्टर में मान केवल-पढ़ने के लिए हैं। जब बनाया जाता है, तो वेक्टर निम्नानुसार दिखाई देता है:

स्थिरांकवेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};

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

इटरेटर के साथ निर्माण

एक टेम्प्लेट डेटा प्रकार के लिए एक सामान्य प्रतिनिधित्व प्रदान करता है। एक पुनरावर्तक एक कंटेनर के मूल्यों के माध्यम से स्कैनिंग का एक सामान्य प्रतिनिधित्व प्रदान करता है। एक पुनरावर्तक के साथ एक वेक्टर बनाने का सिंटैक्स इस प्रकार है:

टेम्पलेट<क्लास इनपुटइटरेटर>
वेक्टर(इनपुटइटरेटर पहले,इनपुट इटरेटर अंतिम,स्थिरांकसंभाजकऔर =संभाजक());

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

एक वेक्टर को नष्ट करना

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

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

size_type क्षमता () const noexcept

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

वेक्टर<पानी पर तैरना>वीटीआर(4);
NSएक पर=वीटीआरक्षमता();
लागत<<एक पर<< 'एन';

आउटपुट 4 है।

आरक्षित (एन)

मेमोरी स्पेस हमेशा स्वतंत्र रूप से उपलब्ध नहीं होता है। अतिरिक्त स्थान अग्रिम में आरक्षित किया जा सकता है। निम्नलिखित कोड खंड पर विचार करें:

वेक्टर<पानी पर तैरना>वीटीआर(4);
वीटीआररिज़र्व(6);
लागत<<वीटीआरक्षमता() << 'एन';

आउटपुट 6 है। तो, आरक्षित अतिरिक्त स्थान 6 - 4 = 2 तत्व है। फ़ंक्शन शून्य लौटाता है।

आकार () बिना किसी अपवाद के;

यह वेक्टर में तत्वों की संख्या देता है। निम्नलिखित कोड इस फ़ंक्शन को दिखाता है:

वेक्टर<पानी पर तैरना>वीटीआर(4);
पानी पर तैरनाएस=वीटीआरआकार();
लागत<<एस<< 'एन';

आउटपुट 4 है।

जमा करने के लिए हटना()

रिजर्व () फ़ंक्शन के साथ एक वेक्टर को अतिरिक्त क्षमता देने के बाद, वेक्टर को उसके मूल आकार में फिट करने के लिए आकार दिया जा सकता है। निम्नलिखित कोड इसे दिखाता है:

वेक्टर<पानी पर तैरना>वीटीआर(4);
वीटीआररिज़र्व(6);
वीटीआरजमा करने के लिए हटना();
NSएस=वीटीआरआकार();
लागत<<एस<< 'एन';

आउटपुट 4 है और 6 नहीं है। फ़ंक्शन शून्य हो जाता है।

आकार बदलें (sz), आकार बदलें (sz, c)

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

वेक्टर<पानी पर तैरना>vtr1{१.१, २.२, 3.3, 4.4};
वीटीआर1.आकार(2);
लागत<< 'vtr1 का नया आकार:' <<वीटीआर1.आकार() << 'एन';
वेक्टर<पानी पर तैरना>vtr2{१.१, २.२};
vtr2.आकार(4, 8.8);
लागत<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << 'एन';

आउटपुट निम्नलिखित है:

vtr1 का नया आकार: 2
vtr2: 1.1 2.2 8.8 8.8

कार्य शून्य लौटते हैं।

खाली () स्थिरांक कोई अपवाद नहीं है

यदि वेक्टर में कोई तत्व नहीं है तो यह फ़ंक्शन सत्य के लिए 1 लौटाता है और यदि वेक्टर खाली है तो असत्य के लिए 0 देता है। यदि किसी वेक्टर में किसी विशेष प्रकार के डेटा के लिए 4 स्थान हैं, जैसे कि फ्लोट, बिना किसी फ्लोट मान के, तो वह वेक्टर खाली नहीं है। निम्नलिखित कोड इसे दिखाता है:

वेक्टर<पानी पर तैरना>वीटीआर;
लागत<<वीटीआरखाली() << 'एन';
वेक्टर<पानी पर तैरना>वीटी(4);
लागत<<ताकिखाली() << 'एन';

वेक्टर<पानी पर तैरना>वी(4,3.5);
लागत<<वीखाली() << 'एन';

आउटपुट निम्नलिखित है:

1
0
0

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

एक वेक्टर को एक सरणी की तरह उप-स्क्रिप्टेड (अनुक्रमित) किया जा सकता है। सूचकांक की गिनती शून्य से शुरू होती है।

वेक्टरनाम[i]

ऑपरेशन वेक्टरनाम [i] i . पर तत्व का संदर्भ देता हैवांवेक्टर का सूचकांक। निम्नलिखित कोड उपरोक्त वेक्टर के लिए 3.3 आउटपुट करता है:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
पानी पर तैरनाफ्लोरिडा=वीटीआर[2];
लागत<<फ्लोरिडा<< 'एन';

वेक्टरनाम [i] कॉन्स्ट

ऑपरेशन वेक्टरनाम [i] कॉन्स्ट को वेक्टरनाम [i] के बजाय निष्पादित किया जाता है जब वेक्टर एक स्थिर वेक्टर होता है। इस ऑपरेशन का उपयोग निम्नलिखित कोड में किया जाता है:

स्थिरांकवेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
पानी पर तैरनाफ्लोरिडा=वीटीआर[2];
लागत<<फ्लोरिडा<< 'एन';

व्यंजक i . का निरंतर संदर्भ देता हैवांवेक्टर का तत्व।

सबस्क्रिप्ट के साथ एक मान असाइन करना

एक गैर-स्थिर वेक्टर को एक मान निम्नानुसार सौंपा जा सकता है:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वीटीआर[2] = 8.8;
लागत<<वीटीआर[2] << 'एन';

आउटपुट 8.8 है।

वेक्टरनाम.at(i)

vectorName.at(i) vectorName[i] की तरह है, लेकिन vectorName.at(i) अधिक विश्वसनीय है। निम्नलिखित कोड दिखाता है कि इस वेक्टर का उपयोग कैसे किया जाना चाहिए:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
पानी पर तैरनाफ्लोरिडा=वीटीआरपर(2);
लागत<<फ्लोरिडा<< 'एन';
पर()एक वेक्टर सदस्य हैसमारोह.

vectorName.at(i) const

vectorName.at(i) const, vectorName[i] const जैसा है, लेकिन vectorName.at(i) const अधिक विश्वसनीय है। vectorName.at(i) const को vectorName.at(i) के बजाय निष्पादित किया जाता है जब वेक्टर एक स्थिर वेक्टर होता है। यह वेक्टर निम्नलिखित कोड में प्रयोग किया जाता है:

स्थिरांकवेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
पानी पर तैरनाफ्लोरिडा=वीटीआरपर(2);
लागत<<फ्लोरिडा<< 'एन';
पर() स्थिरांकएक वेक्टर सदस्य हैसमारोह.

at() फ़ंक्शन के साथ एक मान असाइन करना

एक गैर-स्थिर वेक्टर को at() फ़ंक्शन के साथ एक मान असाइन किया जा सकता है, जो निम्नानुसार है:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वीटीआरपर(2) = 8.8;
लागत<<वीटीआर[2] << 'एन';

आउटपुट 8.8 है।

सब-स्क्रिप्टिंग के साथ समस्या

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

सामने()

यह तत्व को हटाए बिना वेक्टर के पहले तत्व का संदर्भ देता है। निम्नलिखित कोड का आउटपुट 1.1 है।

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
पानी पर तैरनाफ्लोरिडा=वीटीआरसामने();
लागत<<फ्लोरिडा<< 'एन';

तत्व वेक्टर से नहीं हटाया जाता है।

सामने () स्थिरांक

जब वेक्टर निर्माण कॉन्स्ट से पहले होता है, तो फ्रंट () के बजाय एक्सप्रेशन फ्रंट () कॉन्स्ट को निष्पादित किया जाता है। यह निम्नलिखित कोड में प्रयोग किया जाता है:

स्थिरांकवेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
पानी पर तैरनाफ्लोरिडा=वीटीआरसामने();
लागत<<फ्लोरिडा<< 'एन';

एक निरंतर संदर्भ लौटाया जाता है। तत्व वेक्टर से नहीं हटाया जाता है।

वापस()

यह तत्व को हटाए बिना वेक्टर के अंतिम तत्व का संदर्भ देता है। निम्नलिखित कोड का आउटपुट 4.4 है।

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
पानी पर तैरनाफ्लोरिडा=वीटीआरवापस();
लागत<<फ्लोरिडा<< 'एन';

पीछे () स्थिरांक

जब वेक्टर निर्माण कॉन्स्ट से पहले होता है, तो बैक () के बजाय एक्सप्रेशन बैक () कॉन्स्ट को निष्पादित किया जाता है। यह निम्नलिखित कोड में प्रयोग किया जाता है:

स्थिरांकवेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
पानी पर तैरनाफ्लोरिडा=वीटीआरवापस();
लागत<<फ्लोरिडा<< 'एन';

एक निरंतर संदर्भ लौटाया जाता है। तत्व वेक्टर से नहीं हटाया जाता है।

वेक्टर डेटा एक्सेस

डेटा () को छोड़कर; डेटा () बिना किसी अपवाद के;

इनमें से कोई भी एक सूचक देता है जैसे कि [डेटा (), डेटा () + आकार ()) एक वैध सीमा है।

यह बाद में लेख में अधिक विस्तार से कवर किया जाएगा।

रिटर्निंग इटरेटर्स और वेक्टर

एक पुनरावर्तक एक सूचक की तरह है लेकिन एक सूचक की तुलना में अधिक कार्यक्षमता है।

शुरू () कोई अपवाद नहीं

एक पुनरावर्तक देता है जो वेक्टर के पहले तत्व को इंगित करता है, जैसा कि निम्न कोड खंड में है:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना> ::इटरेटरआईटीईआर=वीटीआरशुरू();
लागत<< *आईटीईआर<< 'एन';

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

शुरू () बिना किसी अपवाद के;

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

स्थिरांकवेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना> ::const_iteratorआईटीईआर=वीटीआरशुरू();
लागत<< *आईटीईआर<< 'एन';

आउटपुट 1.1 है। ध्यान दें कि इस बार लौटाए गए इटरेटर को प्राप्त करने के लिए केवल इटरेटर के बजाय const_iterator का उपयोग किया गया है।

अंत () कोई अपवाद नहीं

एक पुनरावर्तक देता है जो वेक्टर के अंतिम तत्व से तुरंत आगे की ओर इशारा करता है। निम्नलिखित कोड खंड पर विचार करें:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना> ::इटरेटरआईटीईआर=वीटीआरसमाप्त();
लागत<< *आईटीईआर<< 'एन';

आउटपुट 0 है, जो अर्थहीन है, क्योंकि अंतिम तत्व से परे कोई ठोस तत्व नहीं है।

अंत () स्थिरांक कोई अपवाद नहीं है

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

स्थिरांकवेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना> ::const_iteratorआईटीईआर=वीटीआरसमाप्त();
लागत<< *आईटीईआर<< 'एन';

आउटपुट 0 है। ध्यान दें कि इस बार लौटाए गए इटरेटर को प्राप्त करने के लिए केवल इटरेटर के बजाय const_iterator का उपयोग किया गया है।

रिवर्स इटरेशन

एक पुनरावर्तक होना संभव है जो अंत से पहले तत्व से ठीक पहले पुनरावृत्त हो।

rbegin () कोई अपवाद नहीं

एक पुनरावर्तक देता है जो वेक्टर के अंतिम तत्व को इंगित करता है, जैसा कि निम्न कोड खंड में है:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना> ::रिवर्स_इटरेटरराइटर=वीटीआररबेगिन();
लागत<< *राइटर<< 'एन';

आउटपुट 4.4 है।

ध्यान दें कि रिवर्स इटरेटर प्राप्त करने वाली घोषणा घोषित कर दी गई है। इटरेटर को रिटर्न एक्सप्रेशन में उसी तरह से मूल्य प्राप्त करने के लिए संदर्भित किया जाता है जैसे एक पॉइंटर को संदर्भित किया जाता है।

rbegin () const noexcept;

एक पुनरावर्तक देता है जो वेक्टर के अंतिम तत्व को इंगित करता है। जब वेक्टर निर्माण कॉन्स्ट से पहले होता है, तो अभिव्यक्ति rbegin () const को rbegin () के बजाय निष्पादित किया जाता है। इस शर्त के तहत, वेक्टर में संबंधित तत्व को संशोधित नहीं किया जा सकता है। इस सुविधा का उपयोग निम्नलिखित कोड में किया जाता है:

स्थिरांकवेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना> ::const_reverse_iteratorराइटर=वीटीआररबेगिन();
लागत<< *राइटर<< 'एन';

आउटपुट 4.4 है।

ध्यान दें कि इस बार लौटाए गए इटरेटर को प्राप्त करने के लिए, केवल रिवर्स_इटरेटर के बजाय, const_reverse_iterator का उपयोग किया गया है।

रेंडर () कोई अपवाद नहीं

एक पुनरावर्तक देता है जो वेक्टर के पहले तत्व से ठीक पहले इंगित करता है। निम्नलिखित कोड खंड पर विचार करें:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना> ::रिवर्स_इटरेटरराइटर=वीटीआरबनाता है();
लागत<< *राइटर<< 'एन';

आउटपुट 0 है, जो अर्थहीन है, क्योंकि पहले तत्व के ठीक पहले कोई ठोस तत्व नहीं है।

रेंडर () const noexcept

एक पुनरावर्तक देता है जो वेक्टर के पहले तत्व से ठीक पहले इंगित करता है। जब वेक्टर निर्माण कॉन्स्ट से पहले होता है, तो अभिव्यक्ति रेंडर () कॉन्स्ट को रेंडर () के बजाय निष्पादित किया जाता है। निम्नलिखित कोड खंड पर विचार करें:

स्थिरांकवेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना> ::const_reverse_iteratorराइटर=वीटीआरबनाता है();
लागत<< *राइटर<< 'एन';

आउटपुट 0 है।

ध्यान दें कि इस बार लौटाए गए इटरेटर को प्राप्त करने के लिए, केवल रिवर्स_इटरेटर के बजाय, const_reverse_iterator का उपयोग किया गया है।

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

एक संशोधक जो वेक्टर को संशोधित करता है वह एक पुनरावर्तक ले सकता है या वापस कर सकता है।

a.emplace(p, args)

p से पहले std::forward(args)… के साथ निर्मित T प्रकार का ऑब्जेक्ट सम्मिलित करता है।

विवरण के लिए - बाद में देखें

सम्मिलित करें (पुनरावर्तक स्थिति, मान)

वेक्टर की पुनरावृत्त स्थिति पर मान की एक प्रति सम्मिलित करता है। वेक्टर में इटरेटर (स्थिति) लौटाता है जहां प्रतिलिपि रखी गई है। निम्न कोड दिखाता है कि मान कहाँ रखा गया है:

वेक्टर<NS>वीटीआर{10, बीस, 30, 40};
वेक्टर<NS> ::इटरेटरआईटीईआर=वीटीआरशुरू();
++आईटीईआर;
++आईटीईआर;
वीटीआरडालने(आईटीईआर, 25);
लागत<<वीटीआर[1] << '' <<वीटीआर[2]<< '
'
<<वीटीआर[3] << 'एन';

आउटपुट है: 20 25 30।

ध्यान दें कि इटरेटर एक पॉइंटर की तरह ही उन्नत (वृद्धिशील) था।

एक इनिशियलाइज़र सूची भी डाली जा सकती है, जैसा कि निम्न कोड दिखाता है:

वेक्टर<NS>वीटीआर{10, बीस, 30, 40};
वेक्टर<NS> ::इटरेटरआईटीईआर=वीटीआरशुरू();
++आईटीईआर;
++आईटीईआर;
वीटीआरडालने(आईटीईआर, {25, 28});

लागत<<वीटीआर[1] << '' <<वीटीआर[2]<< '
'
<<वीटीआर[3]<< '' <<वीटीआर[4] << 'एन';

आउटपुट है: 20 25 28 30।

मिटाना (स्थिति)

इटरेटर द्वारा इंगित स्थिति में एक तत्व को हटा देता है, फिर इटरेटर स्थिति देता है। निम्नलिखित कोड इसे दिखाता है:

वेक्टर<NS>वीटीआर{10, बीस, 30, 40};
वेक्टर<NS> ::इटरेटरआईटीईआर=वीटीआरशुरू();
++आईटीईआर;
++आईटीईआर;
वीटीआरमिटा(आईटीईआर);
लागत<<वीटीआर[0] << '' <<वीटीआर[1] << '
'
<<वीटीआर[2]<< 'एन';

आउटपुट है: १० २० ४०

पुश_बैक (टी), पुश_बैक (आरवी)

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

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वीटीआरवापस धक्का देना(5.5);
पानी पर तैरनाफ्लोरिडा=वीटीआर[4];
लागत<<फ्लोरिडा<< 'एन';

आउटपुट 5.5 है।

वापस धक्का देना(आरवी): -बाद में देख।

पॉप_बैक ()

अंतिम तत्व को वापस किए बिना हटा देता है। वेक्टर का आकार 1 से कम हो गया है। निम्नलिखित कोड इसे दिखाता है:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वीटीआरपॉप_बैक();
पानी पर तैरनाएस=वीटीआरआकार();
लागत<<एस<< 'एन';

आउटपुट 3 है।

ए.स्वैप (बी)

दो वैक्टरों की अदला-बदली की जा सकती है, जैसा कि निम्नलिखित कोड खंड में दिखाया गया है:

वेक्टर<पानी पर तैरना>vtr1{१.१, २.२, 3.3, 4.4};
वेक्टर<पानी पर तैरना>vtr2{10, बीस};
वीटीआर1.विनिमय(vtr2);
लागत<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'
<<vtr1[2] <<''<<vtr1[3] << 'एन';

लागत<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << 'एन';

आउटपुट है:

vtr1: 10 बीस 0 0
vtr2: १.१ २.२ 3.3 4.4

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

स्पष्ट()

वेक्टर से सभी तत्वों को हटा देता है, जैसा कि निम्न कोड खंड दिखाता है:

वेक्टर<पानी पर तैरना>वीटीआर{१.१, २.२, 3.3, 4.4};
वीटीआरस्पष्ट();
लागत<<वीटीआरआकार() << 'एन';

आउटपुट 0 है।

वैक्टर के लिए समानता और संबंधपरक ऑपरेटर

== ऑपरेटर

यदि दो वैक्टर का आकार समान है और संबंधित तत्व समान हैं, तो सत्य के लिए 1 लौटाता है; अन्यथा, यह असत्य के लिए 0 लौटाता है। उदाहरण के लिए:

वेक्टर<NS>यू{1, 2, 3};
वेक्टर<NS>वी{4, 5, 6};
बूल ब्लू=यू==वी;
लागत<<बीएल<< 'एन';

आउटपुट 0 है।

!= ऑपरेटर

यदि दो वैक्टर का आकार समान नहीं है और/या संबंधित तत्व समान नहीं हैं, तो सत्य के लिए 1 लौटाता है; अन्यथा, यह असत्य के लिए 0 लौटाता है। उदाहरण के लिए:

वेक्टर<NS>यू{1, 2, 3};
वेक्टर<NS>वी{4, 5, 6};
बूल ब्लू=यू! =वी;
लागत<<बीएल<< 'एन';

आउटपुट 1 है।

NS

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

वेक्टर<NS>यू{3, 1, 1};
वेक्टर<NS>वी{3, 2, 1};
बूल ब्लू=यू<वी;
लागत<<बीएल<< 'एन';

आउटपुट 1 है।

> ऑपरेटर

रिटर्न! (यू

NS<= Operator

रिटर्न यू<= V, where U is the first vector and V is the second vector, according to the above definitions.

>= ऑपरेटर

रिटर्न! (यू<= V), where U is the first vector and V is the second vector, according to the above definitions.

निष्कर्ष

एक वेक्टर अनुक्रम कंटेनर का एक उदाहरण है। एक वेक्टर साधारण सरणी का एक बेहतर रूप है और इसे एक वर्ग से त्वरित किया जाता है। वेक्टर में ऐसी विधियाँ होती हैं जिन्हें वर्गीकृत किया जाता है: निर्माण और असाइनमेंट, क्षमता, तत्व पहुँच, डेटा एक्सेस, इटरेटर, संशोधक और संख्यात्मक अतिभारित ऑपरेटर।

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