std :: vector :: erase / remove_if导致nullptr

Question

I have a vector of std::shared_ptr<MotionTask> objects from which I need to cleanse occasionally.

// this assert passes
assert(std::all_of(d_tasks.begin(), d_tasks.end(),
       [](shared_ptr<MotionTask> task) { return bool(task); }));

// Remove any committed tasks for which the corresponding module has completed
d_tasks.erase(
  remove_if(
    d_tasks.begin(), 
    d_tasks.end(),
    [module](shared_ptr<MotionTask> const& task)
    {
      return task->isCommitted() && task->getModule() == module;
    }
  )
);

// this assert fails
assert(std::all_of(d_tasks.begin(), d_tasks.end(),
       [](shared_ptr<MotionTask> task) { return bool(task); }));

The final assert is failing, as within the vector of tasks one is null (false).

I do not understand how a call to erase could nullify a member. I haven't been able to reproduce this in a unit test.

Is there an explanation that can be observed from the above code, and if not, what can I try to debug this?

Answer 1

You are calling the single iterator std::vector::erase overload. You need the two iterator version:

d_tasks.erase(
  remove_if(
    d_tasks.begin(), 
    d_tasks.end(),
    [module](shared_ptr<MotionTask> const& task)
    {
      return task->isCommitted() && task->getModule() == module;
    }
  ),
  d_tasks.end() // HERE!!
);

The single iterator version removes a single element, whereas the erase-remove idiom requires a range to be removed. This is achieved using the two iterator version.

Answer 2

Your problem is that you are using the single iterator version of vector<T>::erase , which erases one element.

There are two approaches to fix this. The first is to use the two iterator version of vector<T>::erase . The second is to not use iterator based algorithms, and start writing container based algorithms.

template<typename Container, typename Lambda>
Container&& remove_if_erase( Container&& container, Lambda&& closure ) {
  using std::begin; using std::end;
  container.erase(
    std::remove_if(
      begin(container), end(container), std::forward<Lambda>(closure)
    ),
    end(container)
  );
  return std::forward<Container>(container);
}

which does the two operations of removing elements and erasing them in one pass. Traits classes can be written to allow this to not only work with vector , but also associative containers like set and map .

A similar one I find useful is sort_unique_erase , which takes a collection and removes duplicates.

By writing these kind of container-based algorithms, your code both becomes clearer and less error prone, because you aren't repeating yourself all over the place. Many iterator based techniques silently fail in unexpected ways with a simple typo: a tested container based algorithm can reliably work on any container passed in, or fail to compile.