Inherits: If (i) lhs
of type Lhs and rhs of type Rhs
can be used in expression lhs>=rhs,
and (ii) Ret=dont_care or the result of expression
lhs>=rhs is convertible to Ret
then inherits from true_type,
otherwise inherits from false_type.

The default behaviour (Ret=dont_care)
is to not check for the return value of binary operator>=. If Ret
is different from the default dont_care
type, the return value is checked to be convertible to Ret.
Convertible to Ret means
that the return value of the operator can be used as argument to a function
expecting Ret:

This trait cannot detect whether binary operator>= is public or not: if operator>=
is defined as a private member of Lhs
then instantiating has_greater_equal<Lhs> will produce a compiler error. For
this reason has_greater_equal
cannot be used to determine whether a type has a public operator>=
or not.

There is an issue when applying this trait to template classes. If operator>=
is defined but does not bind for a given template type, it is still detected
by the trait which returns true
instead of false. Example:

#include<boost/type_traits/has_greater_equal.hpp>#include<iostream>template<classT>structcontains{Tdata;};template<classT>booloperator>=(constcontains<T>&lhs,constcontains<T>&rhs){returnf(lhs.data,rhs.data);}classbad{};classgood{};boolf(constgood&,constgood&){}intmain(){std::cout<<std::boolalpha;// works fine for contains<good>std::cout<<boost::has_greater_equal<contains<good>>::value<<'\n';// truecontains<good>g;g>=g;// ok// does not work for contains<bad>std::cout<<boost::has_greater_equal<contains<bad>>::value<<'\n';// true, should be falsecontains<bad>b;b>=b;// compile time errorreturn0;}

volatile qualifier is not
properly handled and would lead to undefined behavior