Question

Suppose I have a long sequence of unordered elements S s1, s2, s3,.... of a arbitrary but fixed data type through which I wish to iterate and delete certain elements according to some boolean criterion.

Now if after iterating through the sequence if I am not interested in the final ordering of the sequence then I can store my sequence in 2 ways

1. Use a plain ol’ std::list to represent the sequence. Perform removal with the std::list methods.
2. Use a std::vector to represent the sequence. If a certain element fails the criterion and has to be deleted swap it with the last vector element and perform a pop_back.

My questions are

1.Which would be a better/efficient way timewise and/or memorywise to store my sequence?

2.If I had to venture a guess, then I would say list, because if si ‘s data-type memory size is large, swapping would be expensive. Would this reasoning be correct?

Answer 1

In practice, std::vector has a great performance advantage over other containers due to its tight memory locality. If your elements are moreover movable (i.e. inexpensive to swap), then your second option should be your first try. Implement it with the standard remove/erase idiom:

v.erase(std::remove_if(v.begin(), v.end(), predicate), v.end());

You should also set up a second version with a std::list and compare the performance:

l.remove_if(predicate);

The list avoids moving any elements around, so in theory it could be efficient, however the practical effects of memory locality cannot be captured by the language standard and you cannot get around measuring and comparing the actual performance.

(Supposedly, if your element type is huge, like sizeof(T) > 10000, the list will probably start being faster than the vector. Test and compare, and keep your code modular such that changing this later is easy.)