Modifying sequence operations with external condition - c++

Question

Often I find myself working with some STL container and wishing to modify it based on some external condition. By external, I mean something that cannot be derived from the object in the container alone.
For example, let's say I have worked out which elements of the container I want to keep based on some elaborate criterion involving not only the elements themselves. The keep flags are stored in a container of the same size as the original container. Now I want to use std::remove_if to remove those for which the flag is zero. How can I do that?
std::vector<Foo> container_of_foos;
std::vector<int> to_keep(container_of_foos.size(), 0);
// ... code calculates which foos to keep and stores a flag for each one
// NOTE: the condition relies information external to the Foo class (could be relation to other Foo instances)
auto i_new_end = std::remove_if(begin(container_of_foos), end(container_of_foos), [&to_keep](const Foo& foo) {
// can't tell whether to keep, because I don't know which object is iterated now
});

Answer 1

Using boost::zip_iterator
boost::zip_iterator over a set of tuple iterators really simplifies the removal.
std::vector<int> numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<bool> selectors = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1};
auto zip_first = boost::make_zip_iterator(
boost::make_tuple(selectors.begin(), numbers.begin()));
auto zip_last = zip_first + std::min(selectors.size(), numbers.size());
auto removed_first = std::remove_if(zip_first, zip_last, [](const auto& tup) {
return boost::get<0>(tup) == 0;
});
Live example on Wandbox.
Using algorithms (non-boost)
Write your own remove/remove_if that takes two ranges (values and selectors) and a value/predicate. You'll have to decide on how you want to handle mismatched range distances. Once you have two ranges in your expected state, you can run compress both by erasing. Below is an example of compressing a range that is filtered using another range, terminating on the shortest sequence.
Remove by value and predicate
template <typename FwdIt1, typename FwdIt2, typename ValueType>
auto remove(FwdIt1 first1, FwdIt1 last1, FwdIt2 first2, FwdIt2 last2,
const ValueType value) {
FwdIt1 curr1 = first1;
FwdIt2 curr2 = first2;
for (; curr1 != last1 && curr2 != last2; ++curr1, ++curr2) {
if (value != *curr2) {
*first1++ = std::move(*curr1);
*first2++ = std::move(*curr2);
}
}
return std::make_pair(first1, first2);
}
template <typename FwdIt1, typename FwdIt2, typename Predicate>
auto remove_if(FwdIt1 first1, FwdIt1 last1, FwdIt2 first2, FwdIt2 last2,
Predicate pred) {
FwdIt1 curr1 = first1;
FwdIt2 curr2 = first2;
for (; curr1 != last1 && curr2 != last2; ++curr1, ++curr2) {
if (!pred(*curr2)) {
*first1++ = std::move(*curr1);
*first2++ = std::move(*curr2);
}
}
return std::make_pair(first1, first2);
}
Container-based Compression (remove & erase) helpers
template <typename Container, typename Selector, typename ValueType>
auto compress(Container& values, Selector& selectors, const ValueType& value) {
const auto remove_iters =
remove(std::begin(values), std::end(values), std::begin(selectors),
std::end(selectors), value);
return std::make_pair(
values.erase(remove_iters.first, std::end(values)),
selectors.erase(remove_iters.second, std::end(selectors)));
}
template <typename Container, typename Selector, typename Predicate>
auto compress_if(Container& values, Selector& selectors, Predicate pred) {
const auto remove_iters =
remove_if(std::begin(values), std::end(values), std::begin(selectors),
std::end(selectors), pred);
return std::make_pair(
values.erase(remove_iters.first, std::end(values)),
selectors.erase(remove_iters.second, std::end(selectors)));
}
Live Example on Wandbox.

Answer 2

In C++11, use a lambda as the predicate. For example;
void func()
{
std::vector<int> container;
// populate container
int flag = 42;
// modify flag as needed
auto lambda = [flag](int element) {return element < flag;} // whatever
std::remove_if(container.begin(), container.end(), lambda);
}
Before C++11, use a functor.
struct remover
{
int flag;
remover(int flag_value) : flag(flag_value) {};
bool operator()(int element) {return element < flag;};
};
void func()
{
std::vector<int> container;
// populate container
int flag = 42;
// modify flag as needed
remover functor(flag);
std::remove_if(container.begin(), container.end(), functor);
}
These two samples are essentially equivalent.
In C++11, look up lambda capture specifications to work out how to pass other variables to the lambda. Before that, change the functor so it is constructed using whatever variables are needed.

Answer 3

&x-vec.data() is the index of x in vec.
Assuming, of course, that x is in vec: otherwise, is UB.