I found that binary_function
is removed from C++11. I am wondering why.
C++98:
template <class T> struct less : binary_function <T,T,bool> {
bool operator() (const T& x, const T& y) const {return x<y;}
};
C++11:
template <class T> struct less {
bool operator() (const T& x, const T& y) const {return x<y;}
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
MODIFIED----------------------------------------------------------------------------
template<class arg,class result>
struct unary_function
{
typedef arg argument_type;
typedef result result_type;
};
For example, if we want to write our adapter for function even in C++98,
template <class T> struct even : unary_function <T,bool> {
bool operator() (const T& x) const {return 0==x%2;}
};
find_if(bgn,end,even<int>()); //find even number
//adapter
template<typename adaptableFunction >
class unary_negate
{
private:
adaptableFunction fun_;
public:
typedef adaptableFunction::argument_type argument_type;
typedef adaptableFunction::result_type result_type;
unary_negate(const adaptableFunction &f):fun_(f){}
bool operator()(const argument_type&x)
{
return !fun(x);
}
}
find_if(bgn,end, unary_negate< even<int> >(even<int>()) ); //find odd number
How can we improve this in C++11 without unary_function
?
It isn't removed, it's just deprecated in C++11. It's still part of the C++11 standard. You can still use it in your own code. It was removed in C++17 though.
It isn't used in the standard any more because requiring implementations to derive from
binary_function
is over-specification.Users should not care whether
less
derives frombinary_function
, they only need to care that it definesfirst_argument_type
,second_argument_type
andresult_type
. It should be up to the implementation how it provides those typedefs.Forcing the implementation to derive from a specific type means that users might start relying on that derivation, which makes no sense and is not useful.
Edit
You don't need it.
In fact you can do even better, see
not_fn
: a generalized negator