Using negation of UnaryPredicate in erase-remove idiom

check the std::not1 function. it does what you want.

v2.erase( std::remove_if(v2.begin(), v2.end(), std::not1(std::ptr_fun(is_odd))), v2.end() );

Live example

Anyway, if it is up to me plus C++11 is available I would prefere:

 v2.erase( std::remove_if(v2.begin(), v2.end(), [&](auto/* or the type */ const& item){return !is_odd(item);}), v2.end() );

because as far as I remember std::not1 was helpful before lambda was available.

You can use std::not1. Sadly, std::not1 requires a function object argument with nested argument_type and result_type types. That is, it can't be used directly. Instead, it is necessary to combine the use with std::ptr_fun when using the negator with a normal function:

    v2.erase( std::remove_if(v2.begin(), v2.end(), std::not1(std::ptr_fun(is_odd))), v2.end() );

At the last committee meeting std::not_fn was moved from the Library Fundamentals TS 2 into the working draft. That is, there is hope that with C++17 there is a better offer for a generic negator.

In general, the fun stops when you need to use any of the std::*_fun functions. As others have pointed out, it may be reasonable to use a lambda instead:

v2.erase( std::remove_if(v2.begin(), v2.end(), [](auto&& x){ return !::is_odd(x); }), v2.end() );

The use of a lambda function or a function object with an inline function call operator also has the advantage that the compiler has an easier time inlining the code.

Obviously, if you need to use C++ prior to C++11 the std::not1/std::ptr_fun approach is the easiest for immediate use an the use of a lambda function isn't even possible. In that case you may want to create a simple function object to support inlining:

struct not_odd {
    template <typename T>
    bool operator()(T const& value) const { return !::odd(value); }
};
// ...
v2.erase( std::remove_if(v2.begin(), v2.end(), not_odd()), v2.end() );