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