Overloaded operators for std::bind placeholders - c++

Question

boost::bind overloads several operators for its placeholders:
For convenience, the function objects produced by bind overload the logical not operator ! and the relational and logical operators ==, !=, <, <=, >, >=, &&, ||.
For example, this allows me to pass _1 == desired_value as a predicate to STL algorithms.
Unfortunately, std::bind does not seem to overload these operators :(
Why is that?
What is a good workaround to simulate _1 == desired_value with std::bind?

Answer 1

IIRC, Boost.Bind only overloads those operators for the placeholders because the original Boost Lambda Library, which Boost.Bind is an improvement of, did (Boost.Bind is obsolete thanks to Boost.Phoenix, btw). std::bind's placeholders are only intended for exactly that purpose, as placeholders for arguments to std::bind.
As a workaround, use polymorphic functors:
struct compare_equal{
template<class LHS, class RHS>
bool operator()(LHS&& lhs, RHS&& rhs){ // assume bool return
return std::forward<LHS>(lhs) == std::forward<RHS>(rhs);
}
};
// ...
auto bound = std::bind(compare_equal(), _1, desired_value);
Live example on Ideone.

Answer 2

You could always overload these operators for the placeholders yourself, for example operator<:
struct less12
{
template<typename T, typename U>
bool operator()(const T& a, const U& b) const
{
return a < b;
}
};
less12 operator<(decltype(_1), decltype(_2))
{
return less12();
}
struct less21
{
template<typename U, typename T>
bool operator()(const U& b, const T& a) const
{
return a < b;
}
};
less21 operator<(decltype(_2), decltype(_1))
{
return less21();
}
template<typename T>
struct lessa1
{
const T& a;
template<typename U>
bool operator()(const U& b) const
{
return a < b;
}
};
template<typename T>
lessa1<T> operator<(const T& a, decltype(_1))
{
lessa1<T> result = {a};
return result;
}
template<typename U>
struct less1b
{
const U& b;
template<typename T>
bool operator()(const T& a) const
{
return a < b;
}
};
template<typename U>
less1b<U> operator<(decltype(_1), const U& b)
{
less1b<U> result = {b};
return result;
}
Here is a usage example, compared with binders (custom less12 vs std::less) and lambda syntax:
template<typename Iterator>
void quicksort(Iterator begin, Iterator end)
{
// ...
auto m = std::partition(begin + 1, end, _1 < *begin);
auto m = std::partition(begin + 1, end, std::bind(less12(), _1, *begin));
auto m = std::partition(begin + 1, end, std::bind(std::less<typename std::iterator_traits<Iterator>::value_type>(), _1, *begin));
auto m = std::partition(begin + 1, end, [begin](const typename std::iterator_traits<Iterator>::value_type& x) { return x < *begin; } );
// ...
}
Really looking forward to N3421 and polymorphic lambdas here :)

Answer 3

std::bind does not seem to overload these operators?
Why is that?
Because C++11 added lambdas which provide the same, if not better, conveniences to produce anonymous functor objects.
What is a good workaround to simulate _1 == desired_value with std::bind?
std::bind is not used to simulate the behavior. Use C++11 lambdas to implement the answer to your question:
std::vector<int>::iterator it = std::find_if (myvector.begin(), myvector.end(), [](int i) -> bool { return i == desired_value; });
Please note that you don't need the "-> bool" syntax if you are using a fairly recent compiler that can derive the return type.
If you don't want to or can't use C++11 lambdas, then you can create a non-anonymous functor like this:
bool IsDesiredValue (int i) {
return (i == desired_value);
}
std::vector<int>::iterator i = std::find_if (myvector.begin(), myvector.end(), IsDesiredValue);
For another example, here is a use of C++11 lambdas being used to create an anonymous functor to sort a vector by a value of a type:
std::sort(myVector.begin(), myVector.end(), [](const Foo& i, const Foo& j) -> bool { return i.myValue < j.myValue; });
An alternative, non-lambda version would be:
struct myclass {
bool operator() (const Foo& i, const Foo& j) { return (i.myValue < j.myValue); }
} myobject;
std::sort(myVector.begin(), myVector.end(), myobject);
And here's how you would do the same sort using boost's operator overload:
std::sort(myVector.begin(), myVector.end(), boost::bind(&MyClass::myValue, _1) < boost::bind(&MyClass::myValue, _2))

Answer 4

I think it is because C++11 has lambda, and therefore I don't see why you would need such operators instead.