std::vector::erase: इंडेक्स द्वारा वेक्टर से एलिमेंट हटाना (C++)

std::vector से इंडेक्स के आधार पर एलिमेंट कैसे हटाएं: अंदर की कार्यप्रणाली

नमस्ते दोस्त! अगर आपने कभी C++ में डायनामिक ऐरे के साथ काम किया है, तो आपने जरूर सोचा होगा: "std::vector<> से इंडेक्स के आधार पर एलिमेंट कैसे हटाएं?" — यह Stack Overflow पर सबसे लोकप्रिय सवालों में से एक है, और यह कोई संयोग नहीं है। पहली नज़र में यह काम बहुत आसान लगता है: बस erase कॉल करें और हो गया। लेकिन असल में मेमोरी में क्या होता है? वेक्टर के बीच से एलिमेंट हटाना इतना महंगा क्यों है? और इटरेटर के साथ गलती कैसे न करें?

इस लेख में हम सिर्फ v.erase(v.begin() + index) लिखना नहीं सिखाएंगे। हम यह समझेंगे कि यह ऑपरेशन अंदर से कैसे काम करता है, कौन सी डेटा स्ट्रक्चर शामिल हैं, और एलिमेंट हटाने का सबसे अच्छा तरीका कैसे चुनें। चलिए शुरू करते हैं!

1. std::vector: यह क्या है?

एलिमेंट हटाने से पहले, आइए याद करें कि std::vector कैसे काम करता है। यह एक डायनामिक ऐरे है जो एलिमेंट्स को मेमोरी के एक सतत (contiguous) ब्लॉक में स्टोर करता है। इसके तीन मुख्य पॉइंटर (या इटरेटर) होते हैं:

\n
• begin — आवंटित मेमोरी की शुरुआत;
\n
• end — उपयोग में ली गई मेमोरी का अंत (अंतिम एलिमेंट के बाद);
\n
• capacity — आवंटित मेमोरी का अंत (जहां तक बिना पुनः आवंटन के बढ़ सकते हैं)।
\n

दृश्य रूप में यह इस तरह दिखता है:

[0] [1] [2] [3] [4] ... [capacity-1]\n ^                        ^\n begin                   end\n

जब आप बीच से कोई एलिमेंट हटाते हैं, तो वेक्टर उसे सिर्फ "बाहर" नहीं फेंकता — यह उसके बाद के सभी एलिमेंट्स को शारीरिक रूप से बाईं ओर खिसका देता है। यही erase ऑपरेशन का सबसे बड़ा "दर्द" है।

2. इंडेक्स के आधार पर हटाना: बेसिक सिंटैक्स

इंडेक्स के आधार पर एलिमेंट हटाने का सबसे आसान तरीका है erase मेथड का इटरेटर के साथ उपयोग करना:

#include <vector>\n#include <iostream>\n\nint main() {\n    std::vector<int> v = {10, 20, 30, 40, 50};\n    int index = 2; // हम तीसरा एलिमेंट (30) हटाना चाहते हैं\n\n    // जांचें कि इंडेक्स सीमा के अंदर है\n    if (index < v.size()) {\n        v.erase(v.begin() + index);\n    }\n\n    for (int x : v) std::cout << x << " ";\n    // आउटपुट: 10 20 40 50\n    return 0;\n}\n

बहुत आसान है, है ना? लेकिन अगर आपको एक साथ कई एलिमेंट हटाने हों तो? इसके लिए erase(first, last) का ओवरलोड है:

v.erase(v.begin() + 1, v.begin() + 3); // इंडेक्स 1 और 2 वाले एलिमेंट हटा देगा\n

3. अंदर क्या होता है? विस्तृत विश्लेषण

अब सबसे दिलचस्प हिस्सा। जब आप v.erase(iterator) कॉल करते हैं, तो अंदर निम्नलिखित होता है:

\n
1. इटरेटर की जांच (डीबग मोड में) — सुनिश्चित करें कि यह वैध है और वेक्टर के किसी एलिमेंट को इंगित करता है।
\n
2. एलिमेंट्स का स्थानांतरण — हटाए गए एलिमेंट के बाद के सभी एलिमेंट्स को एक स्थान बाईं ओर कॉपी (या मूव, यदि टाइप मूव सेमेंटिक्स सपोर्ट करता है) किया जाता है।
\n
3. साइज में कमी — आंतरिक काउंटर size को 1 से घटाया जाता है।
\n
4. डिस्ट्रक्टर — "पूंछ" वाले एलिमेंट (जो अब डुप्लिकेट हो गया है) के लिए डिस्ट्रक्टर कॉल किया जाता है (यदि टाइप ट्रिवियल नहीं है)।
\n

आइए एक सरलीकृत कार्यान्वयन (स्यूडोकोड) देखें:

template<typename T>\ntypename std::vector<T>::iterator\nvector<T>::erase(iterator pos) {\n    // 1. pos के बाद के सभी एलिमेंट्स को एक स्थान बाईं ओर खिसकाएं\n    for (auto it = pos; it != end() - 1; ++it) {\n        *it = std::move(*(it + 1));\n    }\n    // 2. साइज घटाएं\n    --size;\n    // 3. अंतिम एलिमेंट के लिए डिस्ट्रक्टर कॉल करें\n    allocator.destroy(end()); // end() अब पिछले अंतिम एलिमेंट को इंगित करता है\n    return pos; // हटाए गए एलिमेंट के बाद वाले एलिमेंट का इटरेटर लौटाएं\n}\n

std::move पर ध्यान दें — आधुनिक C++ अनावश्यक कॉपी से बचने की कोशिश करता है।