Question

I have two vector<T> in my program, called active and non_active respectively. This refers to the objects it contains, as to whether they are in use or not.

I have some code that loops the active vector and checks for any objects that might have gone non active. I add these to a temp_list inside the loop.

Then after the loop, I take my temp_list and do non_active.insert of all elements in the temp_list.

After that, I do call erase on my active vector and pass it the temp_list to erase.

For some reason, however, the erase crashes.

This is the code:

non_active.insert(non_active.begin(), temp_list.begin(), temp_list.end());
active.erase(temp_list.begin(), temp_list.end());

I get this assertion:

Expression:("_Pvector == NULL || (((_Myvec*)_Pvector)->_Myfirst <= _Ptr && _Ptr <= ((_Myvect*)_Pvector)->_Mylast)",0)

I’ve looked online and seen that there is a erase-remove idiom, however not sure how I’d apply that to a removing a range of elements from a vector<T>

I’m not using C++11.

Answer 1

erase expects a range of iterators passed to it that lie within the current vector. You cannot pass iterators obtained from a different vector to erase.

Here is a possible, but inefficient, C++11 solution supported by lambdas:

active.erase(std::remove_if(active.begin(), active.end(), [](const T& x)
{
    return std::find(temp_list.begin(), temp_list.end(), x) != temp_list.end();
}), active.end());

And here is the equivalent C++03 solution without the lambda:

template<typename Container>
class element_of
{
    Container& container;

    element_of(Container& container) : container(container) {}

public:

    template<typename T>
    bool operator()(const T& x) const
    {
        return std::find(container.begin(), container.end(), x)
            != container.end();
    }
};

// ...

active.erase(std::remove_if(active.begin(), active.end(),
                            element_of<std::vector<T> >(temp_list)),
             active.end());

If you replace temp_list with a std::set and the std::find_if with a find member function call on the set, the performance should be acceptable.