Erasing elements from a vector

Question

I want to clear a element from a vector using the erase method. But the problem here is that the element is not guaranteed to occur only once in the vector. It may be present multiple times and I need to clear all of them. My code is something like this:

void erase(std::vector<int>& myNumbers_in, int number_in)
    {
        std::vector<int>::iterator iter = myNumbers_in.begin();
        std::vector<int>::iterator endIter = myNumbers_in.end();
        for(; iter != endIter; ++iter)
        {
         if(*iter == number_in)
         {
          myNumbers_in.erase(iter);
         }
        }

    }


    int main(int argc, char* argv[])
    {
        std::vector<int> myNmbers;
        for(int i = 0; i < 2; ++i)
        {
         myNmbers.push_back(i);
         myNmbers.push_back(i);
        }

        erase(myNmbers, 1);


        return 0;
    }

This code obviously crashes because I am changing the end of the vector while iterating through it. What is the best way to achieve this ? i.e. is there any way to do this without iterating through the vector multiple times or creating one more copy of the vector?

Answer 1

You could start from the end or update the end when an element is erased.

It would look something like this:

void erase(std::vector<int>& myNumbers_in, int number_in)
    {
        std::vector<int>::iterator iter = myNumbers_in.begin();
        std::vector<int>::iterator endIter = myNumbers_in.end();
        for(; iter != endIter; ++iter)
        {
                if(*iter == number_in)
                {
                        myNumbers_in.erase(iter);
                        endIter = myNumbers_in.end();
                }
        }

    }

Answer 2

Calling erase will invalidate iterators, you could use:

void erase(std::vector<int>& myNumbers_in, int number_in)
{
    std::vector<int>::iterator iter = myNumbers_in.begin();
    while (iter != myNumbers_in.end())
    {
        if (*iter == number_in)
        {
            iter = myNumbers_in.erase(iter);
        }
        else
        {
           ++iter;
        }
    }

}

Or you could use std::remove_if together with a functor and std::vector::erase:

struct Eraser
{
    Eraser(int number_in) : number_in(number_in) {}
    int number_in;
    bool operator()(int i) const
    {
        return i == number_in;
    }
};

std::vector<int> myNumbers;
myNumbers.erase(std::remove_if(myNumbers.begin(), myNumbers.end(), Eraser(number_in)), myNumbers.end());

Instead of writing your own functor in this case you could use std::remove:

std::vector<int> myNumbers;
myNumbers.erase(std::remove(myNumbers.begin(), myNumbers.end(), number_in), myNumbers.end());

Answer 3

Use the remove/erase idiom:

std::vector<int>& vec = myNumbers; // use shorter name
vec.erase(vec.remove(vec.begin(), vec.end(), number_in), vec.end());

What happens is that remove moves all the elements to the end of the vector and returns the iterator to the first element erased. Then erase removes them.

Answer 4

Depending on why you are doing this, using a std::set might be a better idea than std::vector.

It allows each element to occur only once. If you add it multiple times, there will only be one instance to erase anyway. This will make the erase operation trivial. The erase operation will also have lower time complexity than on the vector, however, adding elements is slower on the set so it might not be much of an advantage.

This of course won't work if you are interested in how many times an element has been added to your vector or the order the elements were added.