c++ - मैं इंडेक्स द्वारा std:: vector<> से तत्व कैसे मिटा सकता हूं?




stl erase (6)

मेरे पास std :: vector <int> है, और मैं n'th तत्व को हटाना चाहता हूं। मैं उसको कैसे करू?

std::vector<int> vec;

vec.push_back(6);
vec.push_back(-17);
vec.push_back(12);

vec.erase(???);

Std :: वेक्टर पर मिटाने की विधि अधिभारित है, इसलिए यह शायद कॉल करने के लिए स्पष्ट है

vec.erase(vec.begin() + index);

जब आप केवल एक तत्व को मिटाना चाहते हैं।


असल में, erase कार्य दो प्रोफाइल के लिए काम करता है:

  • एक तत्व को हटा रहा है

    iterator erase (iterator position);
    
  • तत्वों की एक श्रृंखला को हटा रहा है

    iterator erase (iterator first, iterator last);
    

चूंकि std :: vec.begin () कंटेनर की शुरुआत को चिह्नित करता है और यदि हम अपने वेक्टर में ith तत्व को हटाना चाहते हैं, तो हम इसका उपयोग कर सकते हैं:

vec.erase(vec.begin() + index);

यदि आप बारीकी से देखते हैं, vec.begin () हमारे वेक्टर की शुरुआती स्थिति के लिए सिर्फ एक सूचक है और इसके मूल्य को जोड़ने के लिए पॉइंटर को स्थिति में बढ़ाता है, इसलिए इसके बजाय हम पॉइंटर को ith तत्व से एक्सेस कर सकते हैं:

&vec[i]

तो हम लिख सकते हैं:

vec.erase(&vec[i]); // To delete the ith element

तत्व को हटाने के लिए निम्न तरीके का उपयोग करें:

     1  // declaring and assigning array1 
     2  std:vector<int> array1 {0,2,3,4};
     3
     4  // erasing the value in the array
     5  array1.erase(array1.begin()+n);

अधिक विस्तृत अवलोकन के लिए आप यहां जा सकते हैं: - http://www.cplusplus.com/reference/vector/vector/erase/


पिछले उत्तरों का मानना ​​है कि आपके पास हमेशा एक हस्ताक्षरित अनुक्रमणिका है। अफसोस की बात है, std::vector इंडेक्सिंग के लिए size_type का उपयोग करता है, और iterator अंकगणितीय के लिए size_type , इसलिए यदि आपके पास "-Wconversion" और मित्र सक्षम हैं तो वे एक साथ काम नहीं करते हैं। सवाल का जवाब देने का यह एक और तरीका है, जबकि हस्ताक्षरित और हस्ताक्षरित दोनों को संभालने में सक्षम होने के नाते:

दूर करना:

template<class T, class I, class = typename std::enable_if<std::is_integral<I>::value>::type>
void remove(std::vector<T> &v, I index)
{
    const auto &iter = v.cbegin() + gsl::narrow_cast<typename std::vector<T>::difference_type>(index);
    v.erase(iter);
}

लेना:

template<class T, class I, class = typename std::enable_if<std::is_integral<I>::value>::type>
T take(std::vector<T> &v, I index)
{
    const auto &iter = v.cbegin() + gsl::narrow_cast<typename std::vector<T>::difference_type>(index);

    auto val = *iter;
    v.erase(iter);

    return val;
}

यदि आपके पास एक अनियंत्रित वेक्टर है तो आप इस तथ्य का लाभ उठा सकते हैं कि यह अनियंत्रित है और मैंने सीपीपीकॉन में दान हिगिन्स से कुछ देखा

template< typename TContainer >
static bool EraseFromUnorderedByIndex( TContainer& inContainer, size_t inIndex )
{
    if ( inIndex < inContainer.size() )
    {
        if ( inIndex != inContainer.size() - 1 )
            inContainer[inIndex] = inContainer.back();
        inContainer.pop_back();
        return true;
    }
    return false;
}

चूंकि सूची आदेश कोई फर्क नहीं पड़ता है, बस सूची में अंतिम तत्व लें और उस आइटम के शीर्ष पर कॉपी करें जिसे आप निकालना चाहते हैं, फिर अंतिम आइटम पॉप और हटाएं।


erase विधि का उपयोग दो तरीकों से किया जाएगा:

  1. एकल तत्व मिटा रहा है:

    vector.erase( vector.begin() + 3 ); // Deleting the third element
    
  2. तत्वों की श्रेणी को मिटा देना:

    vector.erase( vector.begin() + 3, vector.begin() + 5 ); // Deleting from third element to fifth element
    




erase