Using std::remove_if with lambda predicate to delete multiple elements - c++

Question

What would be the fastest and most efficient way of using std::remove_if with lambda predicate to delete multiple elements at the same time? At the moment I have a point struct with position and unique id. Inside an update loop we fill the points vector and we add points to be deleted at the end of the update loop. At the moment I have to call remove_if inside a loop to remove all the deleted points from the points vector. For example if we add 10 points per frame and after that we loop all the points to check if the point is outside screen bounds, if it is its added to deletedPoints_.
struct Point
{
/// Position.
Vector3 position_;
/// Unique id per point
int id_;
}
/// Current max id
int maxId_;
/// All points
std::vector<Point> points_;
/// Deleted points
std::vector<Point> deletedPoints_;
//Updates with 60fps
void App::Update()
{
/// Add 10 points per frame
for (int i = 0; i < 10; ++i)
{
Point newPoint;
/// Add position
newPoint.position_ = worldPosition;
/// Add id starts from 1
maxId_ += 1;
startPoint.id_ = maxId_;
/// Add new point in points
points_.push(newPoint);
}
/// If points outside of screen bounds add them to deletedPoints_
if (points_.size() > 0)
{
for (int i = 0; i < points_.size(); ++i)
{
/// Bounds
Vector2 min = Vector2(0.00,0.00);
Vector2 max = Vector2(1.00,1.00);
/// Check Bounds
if(points_[i].x < min.x || points_[i].y < min.y || points_[i].x > max.x || points_[i].y > max.y)
{
deletedPoints_.push(points_[i]);
}
}
/// Loop deleted points
for (int i = 0; i < deletedPoints_.size(); ++i)
{
int id = deletedPoints_[i].id_;
/// Remove by id
auto removeIt = std::remove_if(points_.begin(), points_.end(),
[id](const TrailPoint2& point)
{ return point.id_ == id; });
points_.erase(removeIt, points_.end());
}
}
}

Answer 1

Without changing your structures, the quickest fix is to invert the whole loop and check deletedPoints from inside the lambda instead.
Then, make deletedPoints a std::set<int> storing your unique IDs. Then it'll be relatively fast, because std::set<int>::find doesn't need to scan the entire container, though your final complexity will still not be quite linear-time.
std::vector<Point> points_;
std::set<int> deletedPointIds_;
/// Remove by id
auto removeIt = std::remove_if(points_.begin(), points_.end(),
[&](const TrailPoint2& point)
{ return deletedPointIds_.count(point.id_); });
points_.erase(removeIt, points_.end());
deletedPointIds_.clear();
That being said, whether the switch over to std::set will be actually faster depends on a few things; you lose memory locality and drop cache opportunities due to the way in which set's elements are stored.
An alternative might be to keep the vector (of IDs not points!), pre-sort it, then use std::binary_search to get the benefits of a quick search as well as the benefits of sequentially-stored data. However, performing this search may not be suitable for your application, depending on how much data you have and on how often you need to execute this algorithm.
You could also use a std::unordered_set<int> instead of a std::set; this has the same problems as a std::set but the hash-based lookup may be faster than a tree-based lookup. Again, this entirely depends on the size, form and distribution of your data.
Ultimately, the only way to know for sure, is to try a few things at simulated extents and measure it.