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_bit_and<Lhs> will produce a compiler error. For
this reason has_bit_and
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_bit_and.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_bit_and<contains<good>>::value<<'\n';// truecontains<good>g;g&g;// ok// does not work for contains<bad>std::cout<<boost::has_bit_and<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